Every Claude Code session starts with 200,000 tokens of capacity. That’s roughly 200,000 words.
At zero tokens, Claude has nothing to work with.
Load in some context and it gets sharp.
Load in too much and something shifts.
It starts making weird mistakes. It makes assumptions it normally wouldn’t. It forgets things you told it ten minutes ago.
I describe it like working with a coworker who started the day sober and gradually got drunk.
You want to give a coworker enough information to get the job done, but not so much they get overwhelmed and start freelancing.
Same principle applies here. Claude has a zone of genius somewhere in the middle of that 200,000-token window, and your job is to keep it there.
The feel of a session going sideways
Knowing where you are in a session is part intuition, part practice. Like riding a bike - you have to ride it.
But intuition alone isn’t enough.
I keep a small token counter in my terminal that updates in real time. When I start a clean session, about 23% of my tokens are already spoken for - MCP tools, skills, memory files, my CLAUDE.md instructions. That’s normal.
The autocompact buffer eats another 22%.
So I start every session with roughly half my capacity already gone. That’s the space I have to work inside of before things go sideways.
As I work, I watch that number climb.
Some tasks burn tokens fast - a search that pulls back a big file, a tool call that returns a lot of data.
Others barely move the needle.
Over time you develop a feel for the pace.
When the behavior starts getting weird, that’s the signal.
Two ways to recover
Compact is the built-in option. It uses the model to summarize the conversation history and clear the raw history from active context. You can even give it custom instructions: “remember where Dan and I go to dinner.” The number drops back down and you keep working in the same session.
It works, but it interrupts your flow.
And the summary is lossy - details get compressed.
Pause is my preferred approach for a different reason. Instead of compressing the current session, it creates a handoff for the next one.
Here’s what /pause actually does: it commits any uncommitted code, then looks at everything we did and produces a copy-pasteable prompt.
One line describing what we were working on.
One line describing the next step.
A list of files the next session will need.
I grab that output, start a fresh session, paste it in, and the new session picks up where the old one left off. Clean context, full capacity, no degradation.
This is “landing the plane.” You’re not trying to squeeze more miles out of a session that’s getting foggy. You’re giving the next pilot a clear briefing.
Why this matters more than any feature
Most people who get frustrated with Claude Code are hitting context problems without knowing it.
The answers feel off.
The code has subtle bugs.
It starts doing things you didn’t ask for.
The instinct is to blame the model.
Usually it’s the context.
Claude Code has an autocompact feature that kicks in around 160,000-170,000 tokens.
It helps.
It also interrupts your work at unpredictable moments, and the automatic summary might not preserve what you actually needed.
I go back and forth on whether to leave it on.
Right now I’m leaning toward manual compacts and pauses, because I’d rather decide what’s important than let the system guess.
The takeaway
Context management isn’t a setting you configure once. It’s an ongoing skill, like managing your own attention.
Give Claude enough to be useful. Notice when it starts drifting. Land the plane before it crashes.
The people getting the best results from Claude Code aren’t the ones with the cleverest prompts. They’re the ones who learned when to start fresh.