Most people treat AI like a very fast search engine. Ask a question, get an answer, move on. The session ends and nothing carries forward.
I wanted something different. I spend a lot of time maintaining mental models: how I think about markets, which companies I believe in, where AI is heading and what that changes about how I work. Those models are always in motion. A rate decision shifts the options setup on a position. A new model release changes what I think agents can do. The models compound when you update them consistently. They go stale when you don't.
The problem was that Claude had no idea any of this existed when I opened a new chat. Every session started at zero. I'd re-explain my investing approach, my Notion structure, my newsletter stack, the tickers I cared about. It felt like onboarding a contractor who forgets everything overnight. Except the contractor was supposed to be helping me think.
The four problems
I kept trying to fix this as if it were one thing. It wasn't. There were four distinct problems, each needing a different solution.
The first was context loss: every session started from scratch. Not just facts but the whole cognitive setup: what I was tracking, what framework I was using, what I'd already decided.
The second was instruction drift: even when I explained my preferences, I explained them differently each time. The output format varied. The tone shifted. There was no canonical version of "what I want from a stock brief" that Claude could reliably reproduce.
The third was ephemeral output: everything Claude produced disappeared when the chat ended. Research notes, investment summaries, article drafts. None of it accumulated. I was generating insights and then losing them.
The fourth was the live data gap: Claude could reason about my portfolio but had no way to actually see it. I was copy-pasting position data from my brokerage into every session by hand.
I'll go through how I solved each one. The mistake I kept making was reaching for a single solution and being surprised when it only closed part of the gap.
Memory
Claude has a built-in memory feature. It saves facts between conversations: your name, your city, the tools you use.
It helped with small things. But the problem was never that Claude forgot my name. Every conversation still started at zero expertise. No idea how to pull my portfolio data. No idea what I meant by an "investment digest" — when I asked for one, I wanted a specific structure: stock by stock, earnings first, macro context, recent news, then a trade idea. Those preferences live in workflows, not facts. And workflows cannot be stored in a bullet point.
Memory handles context loss for facts. The other three problems were still wide open.
Projects
Claude Projects let you attach persistent instructions to a workspace. Every conversation in that project starts with those instructions already loaded.
I set up a project for investing and wrote out exactly what I wanted: when I ask for a stock brief, here is the format; when I mention a position, assume these tickers are in context; use this tone, return this structure. The formatting problems went away. Claude stopped producing generic output and started producing output that matched how I actually think.
Here is roughly what those instructions looked like:
You are a research analyst for a Wheel options trader.
When given a ticker, produce a briefing with:
1. The Pitch (3–5 sentences, conviction-first)
2. Fundamentals (P/E, revenue growth, margins)
3. Options setup (implied volatility, upcoming earnings)
4. Key risks
5. Trade idea: strike, expiry, premium estimate
Format tables tightly. No preamble. Lead with the signal.
Projects close instruction drift completely. That is their job and they do it well.
But instructions are not outputs. Every research note, every digest, every critique still lived and died inside the chat window. The moment I needed to refer back to last week's analysis, it was gone. Ephemeral output and the live data gap still unsolved.
Artifacts
Claude lets you store files inside a Project and generate artifacts, saved outputs in the interface. I tried using both: research notes as Project files, summaries as artifacts I could refer back to.
It did not work the way I hoped. Project files are read-only: Claude can read them but cannot write to, update, or delete them. Any output that needed iterating required external storage. Artifacts have a similar problem: on mobile, editing is not fully supported, and there is no folder structure. Everything sits in a flat list. You cannot organise outputs by stock, by week, or by decision type. Once you have more than a handful, finding anything becomes its own problem.
The ceiling was clear. I needed something writable, hierarchical, and accessible everywhere. And I still had no solution for the live data gap.
Skills
A skill is a Markdown file that Claude reads at the start of a task. The key word is task, not instruction. A Project instruction shapes how Claude behaves in a conversation. A skill defines a specific job Claude can execute repeatedly — with real-world inputs and structured outputs, the same way every time.
The distinction matters. An instruction says "always format stock research this way." A skill says "here is how to connect to my brokerage, pull my current positions as structured data, and return them in a format any other skill can use." One configures behaviour. The other does work.
The first skill I built was the portfolio data skill. My brokerage (Interactive Brokers) has an API called Flex Query that returns a full account snapshot: stock positions, open options contracts, cash balance, unrealized profit and loss. Most people don't know it exists. I wrote a skill that knows my credentials, calls the API, and parses the response into a clean format. Before it existed, I was copying position data from the brokerage interface by hand every session. Now I say "get my positions" and it takes eight seconds.
That skill does one thing. But it made everything else possible, because every other skill that needs portfolio context calls it first. Skills compose. The portfolio data skill feeds the investment digest skill, which reads my newsletters and maps every mention to my actual holdings. The digest feeds the critique skill, which scores the output across eight dimensions and flags what is weak. Each one is a building block. Together they are a repeatable workflow that runs the same way every time I invoke it.
Building skills sounds technical but does not have to be. There is a skill builder skill that walks through the process: describe what you want the skill to do, and it produces the Markdown file with the right structure. Most skills I use started that way and got refined as the gaps appeared.
Skills close the live data gap. But every skill produces output: research notes, position summaries, critique reports, article drafts. If those outputs disappear at the end of the session, the live data gap is just replaced by the ephemeral output problem again.
Notion
For outputs to accumulate, they need a home that persists across sessions, is writable by skills, is structured enough to find things in later, and works the same on desktop and mobile. Project files failed the writable test. Artifacts failed the structure and mobile tests. Notion passes all four.
Each skill knows exactly which section to write to: the investment digest logs to a brokerage digest database, stock research logs to Investment Research Hub, article drafts log to the Writing project. I use the PARA framework (Projects, Areas, Resources, Archives) from Tiago Forte's Building a Second Brain as the organisational model. That logic translates well to giving Claude concrete placement instructions. "Log this to Resources → Investment Research Hub" works reliably. "Put it somewhere useful" does not.
Early on I kept fixing the placement logic per-skill, which worked until I restructured my Notion layout and had to update every file individually. The actual fix was one dedicated page, a Placement Guide, that maps output types to specific Notion locations. Every skill fetches it before creating anything. One update propagates everywhere. That is the kind of small architectural decision that seems like overkill until the alternative costs you an hour.
With the full system assembled, the picture looks like this:
A workflow in practice: the investment digest
The clearest way to show how this comes together is to walk through one skill from first version to what it is now.
The investment digest started as a simple question: could I read my newsletters through Claude instead of my inbox? The first version was three paragraphs of Project instructions. Fetch unread emails from these senders, summarise what they said, flag anything about my tickers. It worked, but the output was generic: a summary of what the newsletters said, not what they meant for my positions.
The second version added the portfolio data skill as a dependency. Before summarising, the digest now called "get my positions" first, loaded my actual holdings, and then mapped every newsletter mention to a real position or a watchlist ticker. The output changed from a newsletter summary to a position-by-position briefing. Same input, completely different usefulness.
The third version added a Make automation for cleanup. Claude can read my Gmail through a connector but cannot modify it; the connector is read-only. So I built a Make workflow (a tool similar to Zapier) that accepts email IDs from the digest and marks them as read. Now the digest reads, analyses, logs to Notion, and cleans up the inbox in one pass.
The fourth version came after the digest kept pulling in content I did not want mixed with investment analysis. I added a filter to the skill file: exclude these sender domains, flag anything that looks like product news rather than market analysis. The skill update took ten minutes. The next run respected it without any other changes.
That is the actual development loop. Each version fixed something the previous one got wrong. Each failure was a spec.
Where it breaks
The first time the research critique skill flagged a FAIL on analysis I had already decided to act on, I had to sit with that for a minute. I had read the research, felt confident, and was ready to put on the trade. The judge said the bear case was absent. I went back, looked for it myself, found it, and did not put on the trade.
That is the useful version of the story. The less useful version is that I have also ignored the critique when I disagreed with it and turned out to be right. The skill is a check, not a verdict. And the whole system only runs when I start a session. Claude does not check my inbox unprompted, does not monitor my positions, does not execute anything. Every output still requires me to initiate it, read it, and decide what to do with it.
The system has made me faster and more consistent. It has not made me smarter. The decisions are still mine. What it has changed is the ratio: a thirty-minute research session that used to split fifteen minutes on context gathering and fifteen on actual thinking now runs closer to three minutes on context and twenty-seven on thinking. That is real, but it is a different claim than "I gave Claude a brain."
Where to start
The right starting point depends on which problem you are actually trying to solve.
If sessions keep starting from scratch, Projects are the fix. Write out the instructions for something you do repeatedly with Claude: format preferences, context assumptions, output structure. Add them to a Claude Project. That alone will change the quality of output. Most people never need to go further.
If you need Claude to do the same task reliably (not just respond consistently, but actually run a process with real inputs), that is when to build a skill. Start with the data source. One skill that fetches the thing you always fetch by hand. Use the skill builder to scaffold it. Everything else builds on top.
If outputs need to accumulate across sessions, wire up Notion. Pick one output type, one destination, and start there. The Placement Guide comes later, once you have enough skills that updating each one individually starts to hurt.
The system I have today took about three months to accumulate. It is still not finished, because the gaps only become visible when a skill runs and produces something wrong, or produces nothing, or produces the right output in the wrong place. Each failure is a spec. Go fix it, ship the updated skill file, and the next session works better.
That is the actual loop. It is not glamorous, but it compounds.