17 Claude Code Token Management Hacks (Tier 1 to Tier 3)

In the past week or so, people have been complaining about hitting their Claude Code limit insanely fast. Claims like one prompt that used to cost 1% of the limit is now around 10%. Even on a $200/month plan, people are reaching the session limit way too fast. Anthropic acknowledged this and mentioned they're working on peak/off-peak hour adjustments — but even after that, some people were still burning through limits at an alarming rate.

I've been playing around, doing research, and testing different approaches. Here are 17 token management hacks organised from Tier 1 (easy wins) to Tier 3 (advanced), along with the foundational mental model that makes all of them click.

How tokens actually work

Before the hacks, you need to understand this: every time you send a message, Claude rereads the entire conversation from the beginning. All of that counts as tokens.

Message 1 → Claude reads it. Message 2 → Claude rereads message 1, its reply, then message 2. And so on. Your cost compounds exponentially, not linearly.

• Message 1: ~500 tokens
• Message 30: ~15,500 tokens (31× more)
• After 30 messages: potentially 250,000+ cumulative tokens

One developer tracked a 100+ message chat and found 98.5% of all tokens were spent re-reading old history. On top of that, Claude reloads your CLAUDE.md, MCP servers, system prompts, skills, and memory files on every single turn — invisible overhead that drips constantly into your context.

Bloated context doesn't just cost more. It produces worse output. There's a phenomenon called lost in the middle: models pay most attention at the start and end of a session, so everything in the middle gets increasingly ignored. You're paying more and getting less.

Tier 1 — Easy wins (implement today)

1. Start fresh conversations

Use /clear between unrelated tasks. Don't carry context about topic A into a conversation about topic B. Every message in a long chat is exponentially more expensive than the same message in a fresh chat. This single habit is the number one thing that extends session life.

2. Disconnect MCP servers you're not using

Every connected MCP server loads all of its tool definitions into your context on every message. One server alone can add ~18,000 tokens per message. Run /mcp at the start of each session and disconnect anything you don't need right now.

Better yet: where you can find a CLI alternative to an MCP server, use that instead. CLIs are faster, cheaper, and the direction the tooling is heading.

3. Batch prompts into one message

Three separate messages cost roughly three times what one combined message costs. Instead of sending "summarise this", then "extract the issues", then "suggest a fix" as separate messages — send it all in one prompt.

If Claude did something slightly wrong, edit your original message and regenerate rather than sending a follow-up correction. Follow-ups stack onto history permanently; edits replace the bad exchange entirely.

4. Use plan mode before any real task

Plan mode lets Claude map out the approach and ask clarifying questions before touching a single file. The single biggest source of token waste is Claude going down the wrong path — writing code you have to scrap and redo. Plan mode eliminates this.

Add something like this to your CLAUDE.md:

Do not make any changes until you have 95% confidence in what you need to build. Ask follow-up questions until you reach that confidence level.

5. Run /context and /cost

/context shows exactly what's eating your tokens right now: conversation history, MCP overhead, loaded files. /cost shows actual token usage and estimated spend for the current session.

In a completely fresh session with no chat history, you might already be down 51,000 tokens before you type a single word — system prompt, tools, custom agents, skills, memory files. If you don't know this is happening, you can't fix it.

6. Set up a status line

In your terminal, run /statusline and configure it to show your model, a visual progress bar, and your token count (e.g. 52K / 1,000K — 5%). Visibility is the first step to control.

7. Keep your usage dashboard open

Pull up your Claude usage dashboard in a tab and glance at it every 20–40 minutes. You could even set up an automation to ping you on Slack or via text when you're approaching your limit, so you can pace yourself instead of getting blindsided.

8. Be smart with pasting

Before you drop a document or file, ask: does Claude need to read the whole thing? If the bug is in one function, paste just that function. If it just needs one paragraph for context, paste that. Claude needs to be precise; so do you.

Tier 2 — Intermediate tactics

9. Keep your CLAUDE.md lean

Claude auto-reads your CLAUDE.md at the start of every single message as system context. If it's 1,000 lines, every "hi" you send reads those 1,000 lines. Keep it under 200 lines.

Think of it as an index, not a manual. It tells Claude where things live so it can fetch only what it needs. Point to files; don't paste files. This is a mindset shift: lean CLAUDE.md = shorter context on every single turn.

10. Be surgical with file references

Don't say "here's my whole repo, find the bug." Say "check the verifyUser function in auth.js." Use @filename to point at specific files instead of letting Claude explore freely. Every file Claude reads unnecessarily is tokens you don't get back.

11. Compact at 60%, not 95%

Auto-compact triggers at ~95% — by which point your context is already degraded. Check your capacity with /context (or your status line) and run /compact with specific instructions on what to preserve at around 60%.

After three or four compacts in a row, quality starts to degrade. At that point: get a session summary, /clear, paste the summary back, and keep going.

12. Short breaks are costing you

Claude Code uses prompt caching to avoid reprocessing unchanged context — but the cache has a 5-minute timeout. Step away for longer than that and your next message reprocesses everything from scratch at full cost.

If you're stepping away, do a /compact or /clear first. Don't let the cache expiry silently spike your usage.

13. Control command output bloat

When Claude runs shell commands, the full output enters your context window. A git log with 200 commits, a verbose test run, a big ls -R — all of it becomes tokens sent to the model. Be intentional about what you let Claude run. In projects where certain commands aren't needed, deny those permissions upfront.

Tier 3 — Advanced strategies

14. Pick the right model for the job

• Sonnet — default for most coding work
• Haiku — sub-agents, formatting, simple tasks
• Opus — deep architectural planning, only when Sonnet wasn't enough (keep under 20% of usage)

For huge codebases where you want a review pass, consider bringing in a separate tool (like Codex) specifically for review so you're not burning Opus tokens on something a cheaper model could handle.

15. Understand the real cost of sub-agents

Agent workflows use roughly 7–10× more tokens than a standard single-agent session — because each sub-agent wakes up with its own full context, reloading system tools, files, everything.

That said, sub-agents are still useful for one-off tasks — especially if you can delegate them to Haiku. If 80% of your tokens are on a cheap model instead of an expensive one, you're winning. Just be deliberate. Agent teams produce higher quality output, but they're very expensive.

16. Schedule heavy work for off-peak hours

Anthropic adjusts how fast your 5-hour session window drains based on demand. Peak hours (roughly 8am–2pm Eastern on weekdays) drain faster. Off-peak — afternoons, evenings, weekends — your budget lasts longer.

Use this strategically: run big refactors, multi-agent sessions, and large projects off-peak. If you're near a reset with budget left, go heavy — get your money's worth before it resets. If you're near your limit with lots of time left, step away instead of burning the last 5% on something small.

17. Turn your CLAUDE.md into a living constitution

Your CLAUDE.md should contain stable decisions, architecture rules, and progress summaries. Treat it as the source of truth that makes every future prompt shorter. Save decisions, not conversations.

Every architectural call you store there is a paragraph you never have to type again. You can also add rules that tell Claude to be token-aware itself:

If a task needs 3+ files or multi-file analysis, spawn a sub-agent in Haiku and return only summarised insights.

You can even add a self-learning section:

Applied learning: When something fails repeatedly or a workaround is found, add a one-line bullet here. Keep each bullet under 15 words. Only add things that will save time in future sessions.

Just check it regularly — you don't want it ballooning back into the 1,000-line problem.

What to do right now

1. Run /context and see what your fresh-session baseline looks like
2. Set up your status line (/statusline)
3. Pull up your usage dashboard
4. Disconnect unused MCP servers
5. Start your next complex task in plan mode
6. Use /clear when switching to an unrelated task
7. Compact manually at 60% context
8. Batch your multi-step instructions into single messages
9. Schedule heavy sessions for off-peak hours

One last thing on hitting your limit

Hitting your limit shouldn't feel like failure. If you're applying these hacks and not being wasteful, hitting your limit means you're using this tool intensely — which is exactly where the leverage is. The developers who use AI tools to their limits are going to be significantly more productive than those who never get close.

Most people don't need a bigger plan. They need to stop resending their entire conversation history 30 times when 5 would do. It's not a limits problem. It's a context hygiene problem.