I started using Claude Code like it could follow me everywhere.
Open a repo. Ask it to read the structure. Build a feature. Fix an error. Switch to another repo because a different idea started pulling my attention. Come back later and expect the conversation to still understand what mattered.
That fit the way I work.
My projects do not always move in a straight line. Some days I am writing. Some days I am debugging. Some days I am testing a product idea that may not survive the afternoon. Claude Code made that movement easier, so I kept bringing it into more parts of my workflow.
Then my Claude Pro limit started disappearing faster than I expected.
During coding sessions, I could burn through the 5-hour window in less than two hours.
I thought the limit was the issue.
I was on the Pro subscription, not a big API budget. I wanted Claude Code to stay beside me while I moved between coding, planning, debugging, and writing. When the limit ran out early, it felt like the subscription was too small for the way I worked.
The expensive sessions had a pattern
After seeing the same thing happen a few times, I started looking at the sessions that felt expensive.
They had a pattern.
I was not just using Claude Code a lot. I was making it carry too much.
A plan from one repo stayed in the conversation after I had moved on.
A terminal log stayed there after the bug had been fixed.
A design direction stayed in context after I had changed my mind.
Sometimes I asked it to debug something while the conversation still carried product thinking from a different project. Sometimes I came back to a repo and kept using an old thread because it felt easier than starting clean.
I thought the old context was helping.
Some of it was. A lot of it had expired.
Context is part of the workbench
That changed how I understood the problem. I had been treating context like chat history. Something passive. Something that sits behind the work.
It is not passive.
Context is part of the workbench. If I leave everything there, Claude has to work around everything there.
That was when I started paying attention to context hygiene.
Nothing about my setup became complex. I did not build a giant system around it. I changed small habits because the waste was coming from small habits.
Compact, or clear
If I stay inside the same task, I compact after around 10 to 20 prompts. The number is not a rule. It is a checkpoint. After enough back and forth, the conversation starts collecting leftover reasoning. Some parts still matter. Many parts do not.
If I switch tasks, I clear.
That one took time to accept. Clearing context feels like losing momentum. But keeping the wrong context creates a different cost. A coding task does not need the product discussion from another repo. A writing session does not need the full build error from earlier. A bug fix does not need an implementation path I already rejected.
I also stopped using the chat as the only memory layer.
For things that should survive across sessions, I use Obsidian. Project notes, decisions, rough ideas, and things I may want to revisit later. That lets me bring back what matters without asking Claude Code to carry every thread for me.
Logs became context debt
Logs changed too.
Before, I let long command outputs enter the session too easily. The terminal had output, so I gave it output. It felt harmless.
Now I try to give the smallest useful signal: the command, the error, the file, what I expected, and what happened. If the long log matters, I include it. Most of the time, it does not. RTK does part of this for me automatically. It cuts down noisy command output before it enters the conversation. That sounds like a small thing, but in a long coding session, terminal noise becomes context debt.
Shorter answers, less polish
The answers coming back were the other half of the problem.
I use Caveman lite when planning because I still want enough explanation to think. I use Caveman full more when coding because I do not need every answer to sound polished. Shorter answers are not always easier. Sometimes I need to slow down because the answer is compressed. But I prefer that during coding. I would rather read the next useful step than scan through polite assistant language.
The waste hiding inside the code
Then there is the waste that hides inside the code itself.
When AI helps with code, it can overbuild without looking wrong. A small fix becomes a helper. A helper becomes a pattern. A pattern becomes structure for a future I did not ask for.
That extra code is not free. It adds files, branches, explanations, and context for the next prompt.
Ponytail keeps pulling the work back toward the smallest version that holds. I keep it on lite for coding. I turn it off when I work on animation or interaction details, because that kind of work needs more room. If I force animation into the smallest possible shape too early, I lose what I am trying to explore.
Switching repos was the expensive move
Switching repos used to be the most expensive move of all.
When I come back to a repo after days away, the old habit was to reopen an old Claude Code thread and drag it forward just to recover context. Now I use Graphify instead. It keeps a knowledge graph of the project, so I can regain the shape of the codebase without stuffing an expired conversation into the current chat.
The last repo I did this with was my own website. I had been away from it long enough that the structure was no longer in my head. Instead of scrolling through an old thread, I opened the graph. The project came back as clusters. Color showed me which parts belonged together, the lines showed me how they connected, and search took me straight to the piece I needed. That was enough to start the session clean.
Some of the waste was me
I also use a small custom harness, a script that looks at the task and recommends which model and effort level fits it. I still choose based on priority, but the recommendation gives me a useful check.
When I ignore it, I sometimes pay for it.
If I choose too little effort for a task that needs deeper reasoning, the first answer may miss the real shape of the problem. Then I spend more prompts correcting it. What looked cheaper becomes more expensive.
The same thing happens with vague prompts.
If I know what I want but describe it poorly, Claude has to interview me. Sometimes that interview is useful. When I am still shaping the idea, I want the assistant to ask questions.
But if the goal is already clear in my head and I fail to say it, that extra round is on me.
That part was annoying to admit.
Some of my token waste came from the tool.
Some came from the way I used it.
What the workbench looks like now
Now I try to be more deliberate before I ask Claude Code to work.
- If the task can split cleanly, I use subagents instead of dragging every detail through one conversation.
- If I am still in the same context, I compact.
- If I change context, I clear.
- If a note should outlive the session, I put it in Obsidian.
- If output is noisy, I summarize it.
- If code starts growing too much structure, I pull it back.
This did not make Claude Pro unlimited.
Before this setup, I could burn through the 5-hour window in less than two hours during coding. Now I rarely hit the limit before it resets.
I do not think that happened because I became a light user. I still use Claude Code for a lot of things. I still move between repos. I still get excited by ideas before I finish the one in front of me.
The difference is that I notice what I am asking Claude to carry.
That is the part I wish I had understood earlier.
When I first started using Claude Code, I cared most about what it could do. Could it build this? Could it debug that? Could it understand this repo? Could it help me write?
Now I also care about the shape of the workspace I give it.
A stronger model still has to work through the mess I put in front of it.
I still get this wrong. I still keep messy sessions sometimes. I still ignore my own model and effort recommendation when I feel impatient. I still write vague prompts when I am moving too fast.
But I can feel the cost now.
Claude Code works better for me when I stop treating it like an infinite room. I try to treat it more like a workbench.
Context hygiene turned out to be mostly that. Before I ask for help, I notice what belongs on the bench.
And what should stay somewhere else.