Why your Claude Code sessions burn out so fast

Run /context in a session you think is going fine. In an active project I’m usually sitting at 50,000+ tokens before I’ve typed a single word: system prompt, tools, CLAUDE.md, whatever skills loaded with it. That’s the floor, and it gets re-read on every turn.

Meanwhile everyone is blaming the limits. Anthropic shipped a peak-hours adjustment, walked it back, then in May doubled hourly limits for Pro and Max and killed peak-hour throttling entirely. Good. Also beside the point. If your budget disappears in an hour, the ceiling is rarely what did it. Context hygiene did.

The cost compounds

Every message, Claude reads the conversation from scratch. Message 1 through whatever you just sent, plus your CLAUDE.md, plus any active MCP tool definitions, plus system prompt overhead. All of it. Every turn.

Message 1: maybe 500 tokens. Message 30: maybe 15,000, because getting there means re-reading messages 1 through 29. The per-message cost grows in a straight line. The total grows with the square of the message count, so by message 30 the session has burned north of 200,000 tokens. The same work in a fresh session costs a fraction of that.

That’s the chart at the top: one long session climbing in a straight line, against a sawtooth that never passes 5k because /clear runs every ten messages.

More context, worse output

The part I didn’t expect: a longer conversation doesn’t just cost more. It often answers worse.

Liu et al. published “Lost in the Middle” ↗ (opens in a new tab) in 2023, looking at how language models actually use long contexts. The finding: performance degrades for information sitting in the middle of the context window. Models attend well to the start and the end, and what’s sandwiched between gets partially ignored. A U-shaped curve, consistent across models.

So by message 30 you’re paying thirty times what message 1 cost, and the model is probably not making full use of half of what it’s re-reading.

What I actually changed

I’m not going to list eighteen things. Most of them collapse into two ideas anyway: start fresh often, keep what Claude loads small. These are the four or five where I could see the difference.

/clear between unrelated tasks

Biggest impact, and the easiest to understand once compounding clicks. A fresh conversation resets the cost curve to zero and you lose nothing real. The previous task is done. Its history is just weight now.

It feels like throwing away work. It isn’t. The output already exists on disk. The conversation was never the output.

Compact before you’re forced to

Claude Code auto-compacts at around 95% capacity. By then you’ve paid for a lot of low-value reprocessing and quality has already started sliding.

I compact by hand at around 60%, with instructions about what survives:

/compact Keep: current task spec, which files we've changed, any open decisions.
Drop: debug output, intermediate attempts, everything before we landed on the
current approach.

Three or four manual compacts in a row and quality degrades anyway. At that point take a session summary, clear, continue fresh.

The cache cliff

This one stays hidden until you know prompt caching exists. Claude caches your context between messages, and reading from that cache costs roughly a tenth of a full re-read. When the cache expires, the next message pays full price for everything the cache had been covering.

Coffee break, come back, send a message. You just paid full price to re-read a conversation you had already paid for.

The habit survives whatever the number turns out to be. Stepping away for more than a few minutes, run /compact or /clear first. Don’t let the cache expire and rebuild itself silently at full cost.

CLAUDE.md is an index

It loads into context on every single message. Not every session. Every message.

At 800 lines, every “fix this typo” costs 800 lines of overhead first. Keep it under 200. Point at other files instead of pasting them in: Architecture decisions: see docs/architecture.md is close to free at message time, while the architecture doc itself sitting in CLAUDE.md is a bill you pay every turn whether the model needed it or not.

Routing table. It tells Claude where to look, not what to know.

Batch prompts, and edit rather than follow up

Three separate messages cost roughly three times the tokens of one combined message, because of how history accumulates. Follow-up corrections are worse. You spot something wrong, you send a fix, and that wrong exchange sits in context for the rest of the session, billed every turn.

Edit the original message and regenerate. The bad exchange stops existing.

Match the model to the task

Sonnet for most coding work. Haiku for sub-agents doing simple jobs: research synthesis, formatting, moving files around. Opus when the reasoning really needs it, which is rarer than it feels in the moment.

Watch the gauge

None of these habits stick while the spending is invisible:

Set up the status line in your terminal and the context percentage sits inline while you work. Hard to overspend with the number in front of you.

Back to the limits

Peak-hour throttling is gone for Pro and Max, and that helps. But an hour of budget vanishing into one session is almost never a hard compute ceiling. It’s ballast you’ve been dragging since message 4.

Compounding is the whole mental shift. I still catch myself keeping a finished conversation open, because clearing it feels like quitting.

Key takeaways

• Use /clear between tasks. The cost resets to zero, and history after a finished task is weight.
• Compact at 60%, not 95%. Auto-compact arrives long after quality started slipping.
• Stepping away? Compact or clear first. An expired cache costs as much as starting fresh, with none of the benefit.
• Keep CLAUDE.md under 200 lines. It loads on every message, not every session. Keep the knowledge in the files it points at.
• Edit instead of following up. A correction stacked onto history bills you for the mistake every turn after it.
• Sonnet by default, Haiku for sub-agents. Agent teams multiply cost. Use them when the work earns it.

Sources: Liu et al. 2023, “Lost in the Middle” ↗ (opens in a new tab) · Anthropic prompt caching docs ↗ (opens in a new tab)