At the end of the last chapter I told you something that probably sounded like a throwaway line. Claude comes in three different forms, and you have been talking to the one that was built to forget. That was not a throwaway line. It is the single most useful thing most people never learn, and getting it wrong is why your AI feels so much dumber than the demos.
So let me slow all the way down and be plain about this. When people say "Claude," they mean one of three different things, and those three things do not have the same powers. They see different amounts of your actual work. They remember different amounts of you. Sending a task to the wrong one is like asking the receptionist to do the accountant's job. The receptionist is smart. It is just not the person who can open the books.
Here are the three. I am going to describe each one by a single question, because that question is all you need to route your work correctly: what can this one actually see.
Surface one: the Chat
This is the one you know. The website, the box, the conversation. You type, it answers, you type again. It is fast, it is everywhere, and it is where almost everyone spends all of their time.
What can the Chat see? Two things. It sees the conversation, the words you have typed and the words it has typed back, plus anything you paste in. And, importantly, it can reach out to external services you connect to it, your Notion, your Google Drive, and a long list of others, through connectors. That connection is a real capability people miss. The Chat is not sealed off from your other tools. What it cannot do is see the files on your own computer. It cannot open a folder on your hard drive or read your local spreadsheet unless you copy the rows into the box by hand. So its world is the conversation, plus whatever external tools you have plugged in, and none of your local files.
The Chat is perfect for exactly what it looks like it is for. A question. A quick draft. Thinking out loud. Pulling something from a connected tool like Notion. A thing you will not need again. The mistake is not using the Chat. The mistake is trying to do work in the Chat that requires seeing the files on your own machine, and then wondering why you spend the whole time copying and pasting.
Surface two: Cowork, the desktop app
This one lives on your computer as an app, not in a browser tab. And that location is the whole point, because being on your computer means it can see your computer.
What can Cowork see? Your files. Your folders. The stuff on your actual machine. You can point it at a document and it opens the document. You can point it at a folder and it works across everything inside. It can not only read your files, it can act on them, create new ones, edit existing ones, do things on your desktop the way a capable assistant sitting at your computer would. And it keeps the Chat's reach outward too: it can connect to your external tools through the same connectors, so it sees both your local files and your Notion or your Drive.
This is the surface for work that touches the things you already have on your computer. A folder of research. A spreadsheet of numbers. A stack of documents you need something done with. The moment your task involves files that live on your machine, the Chat becomes the wrong tool, because the Chat cannot see local files and Cowork can.
Surface three: Code, the builder's surface
The name scares non-technical people off, and it should not, so let me defuse it. Yes, Code was built for people who write software. But do not let the name fool you into thinking its power is about seeing more than the others. On the two things we just covered, it is not that different: like Cowork, it can see your local files, and like both of the others, it reaches your external tools through connectors. If it were only about what it can see, you would not need a third surface at all.
So what actually makes Code different? It does not just visit your folders, it lives inside them. It works where your project actually sits, in the folder and its history, which developers call a repository, and it can run real work there, not only describe it. This is also the surface where the deepest kind of always-on context lives, the CLAUDE.md file we will build in the next chapter, and where the agent teams we will meet later actually run. The others help you with a task. Code sets up shop inside your project and works there.
You do not need to be a developer to use it. You need to be someone who has real, repeating work living in real folders and wants the surface that can move in and run there. That is most serious operators. The name is a historical accident. Do not let it decide for you.
The one comparison to keep in your head
You do not need to memorize features. You need one picture, and here it is, drawn on the two things that actually differ.
First, local files. The Chat cannot see the files on your computer. Cowork and Code can. Second, external tools. All three can reach out to your connected services like Notion and Drive through connectors, so that is not what separates them. So the real fork is not "which one connects to my tools," they all do. The fork is whether the job touches files on your own machine, and how deep into a project it goes.
Which gives you the routing rule. If the work is a quick question, a throwaway draft, or pulling something from a connected tool, the Chat is fine. If the work needs to open and change files on your computer, you want Cowork. If the work is a real project living in a folder, something you want the AI to move into and run inside, with always-on context and maybe a team of agents, you want Code. The question is never "which is best." The best surface is the one that can reach what the job requires, and go as deep as the job needs.
Here is what that looks like when it is real.
Example: synthesizing twelve customer interviews. Say you just ran twelve discovery calls and you saved every transcript as a file in a folder. Twelve documents. What you want is the pattern across all of them, the thing three different customers said in slightly different words that would take several days for you to catch reading them one at a time.
The naive way is the Chat. You paste in the first transcript, ask for themes, get an answer. Paste the second, ask again. By the fourth you have lost the thread, because the Chat can only hold what is in front of it, and the whole value you were after, the pattern that only appears across all twelve at once, is exactly the thing a one-at-a-time paste cannot see. You are doing synthesis with a tool that can only look at one page at a time.
The built way is to point Code, or Cowork, at the folder. Now the AI can see all twelve transcripts together. You ask for the patterns across the whole set, and it can actually answer, because for the first time the thing you asked about is inside the thing that is looking. The insight that only lives across all twelve calls becomes findable, because the surface could finally see all twelve.
Nothing about your prompt got smarter. You moved the work to the surface that could see the job.
Example: the invoicing spreadsheet. You track your hours in a spreadsheet on your computer and once a month you turn it into invoices. In the Chat, you cannot. The Chat cannot open the file, so you end up copying rows into the box by hand, which is slow and exactly the kind of thing where one wrong paste means one wrong invoice. In Cowork or Code, you point it at the actual spreadsheet and it reads the live file. The work moved to the surface that can touch your files, and the copying disappeared.
How this played out for me
Let me tell you my own path through these surfaces, because it makes a point I could not make any other way, and because the messy parts are the useful parts.
I started in the Chat, like everyone. Then the Claude desktop app arrived with Cowork, and I moved my work there and started building real recurring workflows in it, the weekly things I do on a rhythm. It was good. And then a software update came along and Cowork got unstable for me, unstable enough that the workflows I depended on stopped being reliable. That was my experience at the time, and I am telling you the rough edge on purpose, because it is the whole lesson.
Here is what I did. I tore those workflows down and rebuilt them in Claude Code, which I run through the terminal inside VS Code. That sounds like a painful migration, and the tooling part was. But the thing that made it survivable is the thing this whole book is about. By then I had already built my second brain in Notion, all my context, my standing knowledge, living in a shared place. So when Cowork broke, I lost tooling. I did not lose context. The workflows had to be rebuilt. The knowledge they ran on was untouched, waiting, ready to plug into the new surface. Context outlived the surface, which is exactly why the surface breaking was an annoyance and not a catastrophe.
Today, on my computer, I work only in Claude Code in the VS Code terminal, and usually with several sessions open side by side, so I am advancing a few different pieces of work in parallel and can see them all at once. That is what the surface built for real work looks like in daily practice for a solo operator: not one conversation, but a workshop with several benches going.
And when I am away from my desk, I use the Chat in the mobile app, for sparring and catching ideas before they evaporate. But here is the move that ties it all together. Everything from those mobile chats gets saved back into my Notion second brain. So the next time I sit down at Claude Code, it can reach into Notion and pull up what I was chewing on during a walk. The idea I had on mobile does not live and die on mobile. It flows into the shared context, and the desk surface picks it up like the conversation never paused.
That loop is the whole claim of this chapter, proven on myself. When your context lives in a shared place that all your surfaces can reach, the surface stops mattering. You are not on Chat or Cowork or Code. You are working, continuously, and the surfaces are just the different doors you walk in through depending on where you are and what the job needs. The surfaces are not a ladder you climb once and finish. Your mix keeps changing as your work changes. What stays constant, if you build it, is the context underneath.
What each one remembers when you close it
While we are here, there is a second thing the surfaces differ on, and it is the direct answer to the title of this book. They do not just see different amounts. They remember different amounts.
Think of memory in two buckets. There is the memory that vanishes and the memory that stays.
The single conversation is the vanishing kind. It is alive while it is open and gone when it closes. On top of that, there is now a memory feature that quietly summarizes your conversations, roughly once a day, into a profile it carries into future chats. That is why Claude can feel like it "sort of remembers" you lately. Notice the word summarizes. It is not keeping full transcripts, it is distilling. So it might carry forward that you are a consultant who writes in a certain tone, but not the specific thing you decided in a chat three days ago. Useful, real, but a distilled layer, not total recall. Do not mistake it for the deliberate, always-on context we are about to build, which is exact and which you control.
There is also a feature called projects, and because nearly everyone trips over it the same way, it deserves its own moment.
A project shares what you put in it, not what you say in it
Projects exist in the Chat and in Cowork. A project is a workspace where you attach standing instructions and upload files, and here is the good part: every conversation inside that project automatically reads that project knowledge. You set up the instructions and the files once, and every chat in the project starts already knowing them. That is genuinely useful and it is a real step up from the blank box.
Here is where people, me included early on, get confused and quietly frustrated. You have a great conversation inside a project on Monday. On Wednesday you start a new conversation in the same project and expect it to know what you discussed Monday. It does not. The two conversations in the same project do not see each other's transcripts. The project shares the knowledge you put into it, the instructions and the files, but not the things you say in the individual chats. The memory feature I just described papers over this a little, carrying a distilled summary across, which is exactly why it feels like it "sort of remembers" but keeps missing the specifics.
So learn the rule now and save yourself the frustration. A project shares what you put in it, not what you say in it. If something from a conversation matters for later, do not assume the project absorbed it. Move it into the project knowledge yourself, into the instructions or an uploaded file, so the next conversation actually reads it. That one habit is the difference between a project that compounds and one that keeps forgetting your best thinking.
The deep, always-on memory, the kind that reads you before every task no matter which conversation you are in and holds it exactly, not as a summary, lives in a file called CLAUDE.md, in the project knowledge you deliberately maintain, and in the AI's own running notebook about you. I am naming these now and not explaining them yet, on purpose, because they are the whole of the next chapter. For this chapter, hold only this. The reason your AI forgets you is not stupidity. It is that you have been leaning on the memory that vanishes or only summarizes, instead of the memory you build and control. Move your work onto the right surface and move your important context into project knowledge on purpose, and half the forgetting stops before you have written a single line of the next chapter's setup.
The other half stops when you build the context on purpose. That is next.