Why Is Claude Code Burning So Many Tokens? (And How to See Where They Go)

You started the session an hour ago. It's going fine. And it's quietly costing more with every message — not because the last request was big, but because Claude Code re-sends the entire conversation on every turn. Tokens in a long session don't add up linearly; they compound.

Here's where they go, how to see it, and how to stop the bleed.

The mental model that explains the bill

The context window holds everything: your instructions, every file the agent read, every command's output, every failed attempt, and the whole back-and-forth. On each turn, that whole pile is fed back through the model. So a session that's been running for an hour is re-sending an hour of accumulated context every time you hit enter.

Two consequences people miss:

• Cost scales with session length, not just request size. The 50th message in a bloated session is far more expensive than the 1st, even if you typed the same thing.
• A poisoned session is also an expensive one. Fifteen failed attempts aren't just noise the model has to see past — they're tokens you re-pay for on every subsequent turn.

Where the tokens actually go

The usual culprits, in order:

• Big tool outputs — a giant test log, a cat of a huge file, verbose command output. It sits in context forever after.
• Re-reads — the agent reading the same files over and over (a classic sign of a session going in circles).
• The long tail of the conversation — dozens of turns of reasoning you no longer need.
• Oversized instructions — a 500-line CLAUDE.md is re-sent every turn too. Keep it tight.

How to see it

Claude Code shows how full your context window is as you work — watch that indicator. When it climbs fast, something's dumping a lot into context (usually a big output or a loop). That's your cue to reset before the next turn re-sends all of it.

How to stop the bleed

• /clear between unrelated tasks. Don't let task A's context (and cost) carry into task B.
• /compact within a long task — it summarizes the conversation so you keep the thread without re-sending every token. (Claude Code also auto-compacts near the limit.)
• Scope smaller — short, verifiable tasks keep context lean.
• Use subagents for scoped work — they run in their own context window and return only a summary, so the sub-task's tokens never bloat your main session.
• Kill and restart a poisoned session. Once it's looping, more turns cost more and work worse. A fresh session that opens with the one lesson you learned is cheaper and sharper. (When to shoot it in the head →)

Full breakdown of the reset levers: /clear vs /compact vs kill.

The visibility gap

All of this is manageable in one session. Across five sessions, the question becomes: which one's the token hog? The expensive session is usually the one that's been grinding for 40 minutes — and it's hard to spot in a stack of terminals.

Mwah puts each live session on your desktop as a robot showing its live activity, so the one that's been busy far too long is obvious. Spot it, and end it before it burns another dollar.

---

Related: /clear vs /compact vs kill · Run multiple Claude Code sessions