Token limits in Claude Code punish a mental model almost everyone starts with: that a session is a gas tank, where each message costs a fixed sip. It isn't. Every message re-reads your system prompt, your tool definitions, your memory files, and the entire conversation so far — so cost compounds with length, and message thirty can cost an order of magnitude more than message one. Once I really absorbed that, I stopped blaming my plan size and rebuilt my habits. Same subscription, same projects, dramatically longer sessions — and I run heavy multi-agent workloads on a production Laravel codebase daily, so these habits get stress-tested constantly.
Here are the 18 that survived, in three tiers by effort. The unglamorous ones at the top matter more than the clever ones at the bottom.
Why sessions die: the compounding re-read
Quick mechanics, because every hack below exploits one of three facts:
- History rides along. The whole conversation is re-processed every turn. Long chats aren't linearly expensive — they snowball.
- Overhead rides along too. Connected MCP servers load their full tool schemas into context on every message, whether you use them or not. So do CLAUDE.md and memory files.
- Quality degrades before the window fills. Packed context triggers the "lost in the middle" effect — instructions from early in a long session become functionally invisible. You're paying more for worse output.
Context hygiene beats plan upgrades. A disciplined Pro user outlasts a sloppy Max user, and I say that as someone who has been both.
Tier 1: Quick wins — do these today
1. /clear between unrelated tasks. When you pivot from debugging auth to styling a dashboard, the auth history is still being re-read on every styling message — paying for context that's actively irrelevant. My rule: if the next task doesn't build on the last three messages, clear first. Five seconds of re-establishing context beats dragging twenty dead messages through every turn.
2. Disconnect MCP servers you aren't using. This is my single biggest overhead source, because I run a lot of them — browser automation, design tools, databases, link management. Each one's tool schema loads on every message. Run /context once and look at the tools line; then keep only what the current task needs. On my setup, trimming idle servers reclaims thousands of tokens per turn before I've typed anything.
3. Batch instructions into one message. "Create the component, write its tests, update the barrel export" as one message is one history re-read. As three messages, it's three — each more expensive than the last. Claude handles ordered multi-step instructions well; be explicit about sequence and expected output.
4. Plan mode before anything multi-file. The expensive failure isn't the first wrong attempt — it's the correction cycle it triggers six messages into a bloated session. A cheap planning exchange up front, reviewed and corrected before code exists, is the highest-ROI tokens you'll spend. My threshold: anything touching more than two files or making an architecture decision gets planned first.
5. Run /context and /cost at session start. You can't fix what you can't see. /context breaks down where tokens go — system prompt, tools, memory, history. The first time I looked, a file I'd written once and forgotten was taxing every single turn. Make checking a reflex.
6. Keep a token readout visible. A status line showing context usage turns burn into a fuel gauge. You start noticing which message types are expensive — and that awareness changes behavior without willpower.
7. Paste surgically. Don't paste an 800-line file when 40 lines matter. Everything you paste is re-read every turn afterward. Give the function, the config block, the error output; the agent will ask if it needs more, and asking is cheaper than hauling dead weight.
8. Interrupt wrong output early. Watch long generations start. If the direction is wrong — wrong framework, misread requirement — stop it at 200 tokens, not 2,000. Wrong output doesn't just cost its own generation; it joins the history and taxes every subsequent message.
9. Constrain command output. Shell output enters context in full. A verbose test runner dumping hundreds of passing tests, a fifty-commit git log — all of it becomes permanent per-turn overhead. Ask for failures only, cap log output, and put those defaults in your CLAUDE.md so you never think about it again.
Tier 2: Structural changes — a weekend's work
10. Treat CLAUDE.md as an index, not an encyclopedia. Mine are deliberately small: about 6 KB for the project file, 2 KB global. They hold the architecture at a glance, the commands, the hard rules, and the genuine gotchas — the things the model can't infer from the file tree, like "our composer test runs static analysis, not the test suite." Everything explanatory lives in files the agent reads on demand. The per-turn difference between an index and an encyclopedia is thousands of tokens, on every message, forever.
11. Reference files surgically. "Look at my codebase and suggest improvements" is the most expensive prompt you can write — it licenses a full scan. "Review error handling in src/services/payment.ts, the processRefund function" is a scalpel. Paths, function names, line ranges: the more precisely you aim attention, the less you pay for wandering.
12. Compact at ~60%, not at the auto-trigger. Auto-compaction fires near full capacity — after quality has already been sliding. Compacting earlier preserves more nuance (there's less to compress) and leaves clean runway. Steer it, too: /compact focus on the auth refactoring decisions and the API signatures tells the summary what to keep.
13. Respect the cache timeout. Prompt caching makes repeated context dramatically cheaper — until a coffee break lets the cache expire, and your next message cold-reads the entire conversation at full price. Stepping away for a while? Compact first. Returning to a bloated session after an hour? Often cheaper to /clear and restart with a three-line summary than to pay the cold re-read.
14. Move state to disk — files are free, context is expensive. This one changed how I build every multi-step workflow. When I ran an 84-post content rewrite across several weeks, no session "remembered" anything: a JSON manifest on disk tracked every item DONE or PENDING, backups and drafts lived as files, and each session read exactly the slice of state it needed. Conversation history is the most expensive storage you have access to. Anything durable — progress, decisions, findings — belongs in a file the next turn can read for pennies, not in chat the next turn re-reads at full freight.
Tier 3: How I run heavy multi-agent work
15. Route models by task. Not everything deserves the flagship. My split: top model for planning, architecture, and anything where being wrong is expensive; mid-tier for the bulk of implementation; cheapest for mechanical work — renames, formatting, boilerplate. The premium model earns its cost on judgment, not on typing.
16. Fresh-context workers instead of one long session. The pattern behind that 84-post project: rather than one marathon session accumulating history, I dispatch worker agents in batches — each gets a tight brief, a fresh context, and a small slice of work, then writes results to disk and exits. Twelve posts per worker, seven batches. Every worker runs near the cheap start of the compounding curve instead of the expensive end, and a failed worker costs one batch, not a day. Sub-agents cost real overhead to spin up (each loads the full system prompt, tools, and memory from scratch), so the math only works when the slice is substantial and the result can come back as a file or summary — but when it works, it's the difference between a project that fits your budget and one that doesn't.
17. Pick token-cheap tool transports. Tools differ enormously in what they drag into context. The clearest example I've measured around: driving a browser through Playwright's MCP server streams page snapshots into context every interaction, while the Playwright CLI writes them to disk and lets the agent read what it needs — the Playwright team's own benchmark puts the difference around 4x per task. Same principle applies to any tool choice: prefer the version that leaves data on disk over the version that narrates it into your window. I broke the browser case down fully in Playwright CLI vs MCP inside Claude Code.
18. Prune your instruction layer for the current model generation. Instructions are overhead too, and stale ones are worse than expensive — they're counterproductive. Rules written to constrain older, sloppier models now suppress work newer models would do correctly, while burning context to do it. I audited my own instruction files and found contradictory rules that had been silently fighting each other for months; the method and the findings are in what changed about prompting Claude Opus 5. Fewer, truer instructions: cheaper and better simultaneously.
The mindset that ties it together
Anthropic has published that Claude Code costs average around $6 per developer per day, with 90% of users under $12 — which sounds modest until you realize the variance is behavioral. The developers who hit walls aren't the ones with small plans; they're the ones spending tokens on re-reads, dead context, idle tool schemas, and instructions nobody audited.
Don't implement all 18 this week. Start with three from Tier 1 — clearing between tasks, trimming MCP servers, batching prompts — and let them become reflexes. Add the CLAUDE.md restructure and early compaction next. Tier 3 is for when you're pushing hard enough that incremental gains compound into whole extra working sessions.
And remember what clean context buys beyond money: a model working with 50,000 tokens of relevant context outperforms the same model wading through 200,000 tokens of noise. Token management isn't frugality. It's precision — and the output quality improvement is the part nobody advertises.
For the deeper mechanics of limits and context rot, my context hygiene breakdown picks up where this stops, and managing the 1M-token window covers the big-context era's new failure modes.
Right now, open your active session and run /context. Whatever surprises you in that breakdown — that's your first hack.
Cutting AI spend without cutting output is now a recurring engagement for me — auditing how a team's sessions, agents, and tool stacks burn tokens, then restructuring the workflow so the same budget ships more. If your Claude Code bill is growing faster than your output, see what I offer and get a workflow audit.
