If you re-explain yourself to Claude every time you open a new chat, this is the fix. You'll learn to hand one conversation off to the next, write your standing facts down once, and set up projects that carry all of it for you. Go at your own speed. Nobody is waiting on you.
One idea, three levels: the handoff carries a single conversation to the next, context files carry your standing facts to every conversation, and projects carry all of it automatically. Each section is the same move pointed at a more durable home.
This picks up where From Chat to Code left off, so it helps to have met co-work, the desktop app, and the terminal first. Bring a real thing you're working on, or pick from the menus as you go. Both work.
The fastest fix for a chat that's gone slow and tangled, or a blank new one that's forgotten everything, is a clean handoff. No new tools, no setup. This is where everyone starts.
Most people treat one conversation as sacred. They pile everything into a single chat for days, and when it gets slow or starts giving worse answers, they push harder in the same place. Then the opposite happens: they open a brand new chat and feel like they've lost everything, because now Claude knows nothing about what they were doing.
Both of those are the same missing skill. A long conversation gets heavy. Claude is holding every tangent, every dead end, and every "actually, never mind" you ever typed, and its attention spreads thin across all of it. A fresh chat is lighter and sharper. Starting one isn't losing your progress, as long as you carry the one thing that matters forward. That carry is the handoff, and it's the whole section.
Here's the move that changes everything, and it's almost too simple. Before you leave a conversation, don't try to remember where you are. Ask Claude to write it down for you. It has been in the room the whole time, so it can package the state of your work far better than you'll reconstruct it from memory tomorrow morning.
Go to a real conversation you've had going, one with actual back-and-forth in it, and paste this at the end:
Read what it gives you. This is the thing you carry to the next conversation, so make sure it actually captures where you are. If it missed a decision or a detail that matters, tell it, and have it revise.
Now spend the handoff. Open a new conversation and make the first message the summary you just got, followed by one line that asks Claude to prove it's caught up before you both charge ahead. That little check saves you from building on a misunderstanding.
Watch it come back oriented, ready to keep working, without you re-explaining a thing. That's the entire loop. Long chat gets heavy, ask for a handoff, open a fresh chat, paste it in, keep going. You can do this three times a day and never lose the thread.
A handoff carries one conversation to the next. A context file carries the same facts to every conversation, because you wrote them down once. Same idea you just learned, pointed at a more durable home. Do the handoff section first.
Think about what you type over and over. Who you are and what you do. The project you're in the middle of. How you like things written, the tone you use, the words you'd never be caught using. Every new chat, you explain some slice of it again, and the explaining is dead time before the real work starts.
A handoff fixed that for one conversation. A context file fixes it for good. It's just a plain file where your standing facts live, so any conversation can read it instead of asking you. A handoff is for a moment. A context file is a fact you only have to say once, ever.
You won't write this file from a blank page. You'll let Claude interview you and write it up, the same way you learned to be interviewed in From Chat to Code. Pick one area to start, and paste this:
That's the pattern for any context file. Change what it's about and you can build a whole shelf of them. Make one now, and if the first is easy, make a second:
A file only helps if you use it. So use it. Drop your context file into a conversation, or point Claude at it if it's in a folder you've connected, and tell it to read the file before you start. Then watch it stop asking you things it now already knows.
Pasting the file in every time is already a huge upgrade. The next step up is a file that loads on its own. When you work with Claude Code in a folder, a file named CLAUDE.md is read automatically at the start of every session, no pasting required. It's just a context file with a special name, sitting in the folder it describes. Same idea you learned this section, now it happens without you lifting a finger. The Projects section is where you'll set that up for real.
A project is a home for one body of work, where the context lives with the work and every conversation inside it starts warm. You've built the pieces. This is where they come together, in each tool you already use. This is the section that opens the most doors.
"Project" is a slippery word, so let's pin it down. Sometimes it means a real thing you're making, like a website or a book. Sometimes it means a feature inside the Claude app. And sometimes it means a folder on your computer. Here's the good news: they're all the same idea, and once you see it, all three click at once.
A project is a home for one body of work. Instead of context scattered across a hundred one-off chats, you make a home for this client, or that side business, or your writing, or the family. The instructions and the key files live in the home. Then every conversation you start inside it is already caught up, because the home holds the context so you don't have to carry it. A handoff caught up one chat. A context file caught up any chat that read it. A project catches up every chat automatically, forever, without you doing anything.
The next three lessons set this up in each tool you know: first in the Claude app, then on your computer. Same home, different door.
Start where it's easiest, in the Claude app you already use every day. Projects there are a built-in feature: a named home you can give standing instructions and drop reference files into, so every chat you open inside it begins already briefed.
If writing the instructions feels like a blank page, let Claude do it, the same interview trick as always:
Now the power version, for when you're building with Claude Code in the terminal. On your computer, a project is simply a folder, and that folder can carry its own context in a file named CLAUDE.md. Claude Code reads it automatically at the start of every session, so the folder itself is the home. It's the same Project idea from the app, except it lives right next to your actual files and works where the bigger builds happen.
You don't hand-write this file. You ask Claude Code to look around your folder and write it for you, then you tweak it. Open Claude Code in a folder you work in and paste this:
There's even a built-in shortcut for this. Type /init in Claude Code and it will read your folder and draft a CLAUDE.md on its own. Either way, once the file exists, open a brand new session in that folder and watch it already understand the project before you say a word.
CLAUDE.md is the auto-loading context file from the last section, now in its natural home. You learned what it does. This is where it lives and earns its keep.CLAUDE.md and a fresh Claude Code session used it without you re-explaining the project. If you're not in the terminal yet, mark complete when you understand what this file does and where it lives.Time to make a home you'll actually live in, not a practice one. Pick an area of your work or life that eats the most re-explaining, and give it a real project, in the app or on your computer, whichever fits how you work there.
Here's the whole toolkit now. Handoffs move you cleanly between conversations. Context files mean you write a fact down once and never repeat it. Projects gather all of it into homes that catch up every chat for you. You've gone from re-typing your life every morning to opening a door that already knows you.