For 90 days I logged every single Claude Code session: timestamp, prompt, response, token count, model, exit reason.
430 hours of work. 6 million input tokens. $1,340 in API spend.
Then I sat down with the data and asked the only question that mattered: how much of this was actually doing my work, and how much was overhead?
The answer was uncomfortable: 73% of my tokens went to nine invisible patterns that I'd been doing on autopilot.
Not bad prompts, I write decent prompts.
Not big models when I needed small ones, I knew that one already.
Patterns deeper than that. Patterns nobody talks about because they're invisible until you instrument them.
If you're hitting Claude Max usage limits more than once a week, you have at least 4 of these. Probably 7.
Below: each pattern, exactly how much it costs, and the 30-second fix.
Why this matters now
Anthropic admitted the problem in late March 2026: "people are hitting usage limits in Claude Code way faster than expected."
Max 5 subscribers reported quota exhaustion in 19 minutes instead of the expected 5 hours.
The Pro $200/year users said the limit maxed out every Monday and didn't reset until Saturday - "out of 30 days I get to use Claude 12."
Anthropic acknowledged the issue. The peak-hours quota change in late March explained part of it. The rest was a prompt-caching bug — two independent bugs in the cache layer that silently inflated costs by 10-20x for some sessions.
A user reverse-engineered the Claude Code binary to find it (GitHub issue #40524). Downgrading to v2.1.34 helped some people.
Some of it is real. Most of it is you.
I'm not going to tell you to "use Haiku for simple tasks" or "start a new chat every 15 messages."
Below: the patterns that the obvious advice misses.
The methodology
I ran an HTTP proxy between Claude Code and the Anthropic API. Logged every request: full payload, response, token counts (input/output/cache), latency, model. 90 days. 430 hours of active work.
For each request, I categorized the tokens into:
- Productive — content that directly informed my actual question
- Cache hit (free) — system prompt + CLAUDE.md cached, no marginal cost
- Cache miss (paid) — same content, recomputed because cache expired
- Conversation history re-read — re-tokenizing previous messages on every turn
- Hook injection — pre-pended context from PreToolUse / UserPromptSubmit hooks
- Skill loading — skill SKILL.md content loaded into context for invocations
- Tool use overhead — JSON schemas, tool definitions, tool result blocks
- Extended thinking — <thinking> blocks
- CLAUDE.md — project rules loaded every turn
Productive tokens: 27%. The other 73% is the 9 patterns below, ranked by how much they cost me.
Pattern 1. CLAUDE.md bloat (~14% of total tokens)
The pattern: my CLAUDE.md grew to 4,800 tokens over 6 months. Every turn loaded all 4,800 tokens. Every session loaded them again on each new request. Most of the rules were never relevant to the task at hand.
A 5,000-token CLAUDE.md costs you 5,000 tokens before you've typed a word. Every turn. Every session. A constant baseline tax. Multiply by 200 turns per week and it's 1 million tokens a week of your CLAUDE.md alone.
The 30-second fix:
If you're over 1,500 tokens combined, refactor:
- Move framework-specific rules to project-level CLAUDE.md (only loads in that project)
- Extract repeated patterns into skills (loaded only when invoked)
- Delete anything you can't remember writing
- Convert "explain why" verbose rules into 3-word imperatives
I cut mine from 4,800 to 900 tokens. Same behavior. 31% reduction in baseline cost, instantly.
Pattern 2. Conversation history re-reads (~13% of total tokens)
The pattern: every follow-up message re-tokenizes the entire conversation history. By message 30 in a chat, each turn is paying for messages 1-29 to be read again. The math: at ~500 tokens per exchange, message 30 costs 30× message 1.
I had sessions with 60+ messages. The last message was costing 60× the first. Tokens spent re-reading old context: catastrophic.
The 30-second fix:
1. Edit the prior message instead of follow-up. Up-arrow -> edit -> re-send. The bad exchange gets replaced, not stacked.
1. Hard cap conversations at 20 messages. When you cross 20, ask Claude to summarize what's been done and start a fresh chat with that summary as the first message.
1. Use /compact instead of /clear when you need continuity. /compact summarizes and restarts. /clear nukes everything.
I went from 60-message sessions to 15-message average. 40% drop in conversation re-read cost.
Pattern 3. Hook injection waste (~11% of total tokens)
The pattern: I had 4 plugins installed. Three of them registered UserPromptSubmit hooks that injected context. Combined: 6,200 tokens of hook injection on every prompt I submitted, before Claude even read what I asked.
These hooks are designed to be helpful. They inject branch names, recent file changes, instinct summaries, memory snippets. Each one is small. Together they're a wall.
The 30-second fix:
Audit every hook. If you can't articulate why this hook fires on every prompt, kill it.
I went from 4 active UserPromptSubmit hooks to 1 (just git branch). 5,800 tokens saved per prompt.
Pattern 4. Cache misses on session resume (~10% of total tokens)
The pattern: Anthropic's prompt cache has a 5-minute lifetime by default. Stop work for 6 minutes - cache miss.
The system prompt + CLAUDE.md + tools schema all re-tokenize at full price instead of 10% (cache read price).
I'd take a coffee break. Come back. First message paid full price for ~8K tokens of cached content. Across 90 days, this happened ~640 times.
The 30-second fix:
- Fast workaround: keep a tiny "ping" command bound to a hotkey. Send any prompt within 4 minutes if you're about to take a break. Keeps the cache warm.
- Real fix (paid plans): upgrade to 1-hour cache lifetime. Cache write tokens are 2× base price (one-time, on first write), cache reads are 0.1× base. Math: if you have 10+ resumes per session, the 1-hour cache pays for itself.
I run the 1-hour cache now. Cache miss cost dropped 80%.
Pattern 5. Skill loading on irrelevant tasks (~7% of total tokens)
The pattern: I had 9 skills installed. Each one auto-invokes when Claude detects relevance. The detection is conservative, when in doubt, load. So my UI design skill was loading on backend tasks, my video generation skill was loading on text-only tasks, etc.
Each skill SKILL.md is 800-2,500 tokens. Loaded "just in case." 9 skills × ~1,500 tokens = 13,500 tokens of overhead per task that didn't need any of them.
The fix:
Run a 7-day audit. Which skills did you actually invoke? Disable everything else.
I went from 11 active skills to 4. 9,000+ tokens saved per task on average.
Pattern 6 ."Just in case" tool definitions (~6% of total tokens)
The pattern: I had 12 MCP servers connected. Each one ships its tool schema to every request, regardless of whether the task involves that tool. PostgreSQL MCP server tool schema is ~1,200 tokens.
Twelve MCPs × ~600 avg tokens = 7,200 tokens of tool definitions per request.
I used maybe 3 of these MCPs in 80% of my work.
The 30-second fix:
For permanent control, edit ~/.claude/settings.json to remove unused MCPs from the auto-load list. Re-enable per-session when you actually need them.
I went from 12 to 3 always-on MCPs. 6,000 tokens saved per request.
Pattern 7. Extended thinking on simple questions (~5% of total tokens)
The pattern: I left "Advanced Thinking" / extended thinking on globally. Claude burned 3,000+ tokens of <thinking> on questions that didn't need any reasoning ("rename this variable to camelCase").
Extended thinking is real value when the question genuinely needs reasoning (architecture decisions, complex debugging). On simple tasks it's pure overhead.
The 30-second fix:
Default extended thinking OFF. Toggle ON per-message when you need it (Alt+T in Claude Code).
If your first attempt at a complex task is unsatisfactory, *then* turn extended thinking on for the retry. About 80% of tasks don't need it. The 20% that do you'll know.
Pattern 8. Wrong-direction generation (~4% of total tokens)
The pattern: Claude starts writing a 400-line response. Within the first 50 lines, you can see it's going the wrong way. Most people let it finish, then re-prompt. The remaining 350 lines are wasted output tokens.
Output tokens are billed. Letting Claude finish a wrong response cost me roughly 4% of my total spend. Stupid tax.
The 30-second fix:
Cmd+. (Mac) / Ctrl+. stops generation immediately. Claude keeps what it already wrote. You redirect from there.
I trained myself to use this in the first 5 seconds of any response that's drifting. ~$15/month saved on wasted output.
For Claude Code terminal users specifically, double-Esc opens a checkpoint scroller, you can rewind to any prior state and try a different approach without re-running everything.
Pattern 9. Plugin auto-update redundancy (~3% of total tokens)
The pattern: plugins auto-update on session start. Each update sometimes adds new context to SessionStart hooks. Several of my plugins added small (~50 tokens) info messages that compounded over time. Nine plugins × multiple SessionStart messages = ~1,400 tokens at every session start, just for "loaded successfully" notifications.
The 30-second fix:
I went from 9 SessionStart hooks to 2 (one for branch context, one for env vars). 1,200 tokens saved per session start.
The numbers, side by side
Productive token share went from 27% to roughly 65%. Not 100% — there's an unavoidable floor of overhead. But 65% is a different category of life than 27%.
What didn't work
Things I tried that the obvious blog posts recommend, that didn't move the needle:
1. **Switching to Haiku for "simple" tasks.
**Helped a tiny bit. ~3% reduction. The real waste isn't the model, it's the context bloat described above. Cheaper model on bloated context still costs more than expensive model on lean context.
1. **Aggressive /clear between every task.
**Counter-productive. Lost context I genuinely needed. Better strategy: long-running session per project, but instrumented hooks and lean CLAUDE.md.
1. **Disabling all skills entirely.
**Initially saved tokens. Then I started writing the same 200-token instructions in every prompt manually. Net negative. Better strategy: keep 3-4 skills you actually use, disable the rest.
1. **Off-peak hours scheduling.
**Worked partially. Anthropic's peak-hour quota reduction is real (about 7% of users affected per their statement). For most people the bigger lever is the patterns above, not the time of day.
1. **Pure subscription downgrade (Pro -> less expensive plan).
**Doesn't work. The cost per work-hour stayed the same, just got more painful when limits hit.
1. **Trying to identify the March 2026 caching bug.
**Spent a day on it. Not worth it for individuals, Anthropic patched it. The bigger fish was my own context.
1. The audit script
If you want to instrument your own setup, this script flags all 9 patterns at once:
Save it, run it, fix what's flagged. Re-run weekly until each line is in target.
The mental model shift
The mistake I was making: treating every Claude Code session as a fresh blank slate.
In reality, every session is a long invoice that pre-charges you for:
- Your CLAUDE.md (always)
- Every active plugin's hooks (always)
- Every active skill's SKILL.md (when relevance detected)
- Every connected MCP's tool schema (always)
- Conversation history up to that turn (always)
- Cache miss recompilation (when session resumes after 5 min)
Productive tokens are the residual. What's left after all that overhead.
If you want more productive tokens, which is what "more usage from your plan" actually means, you have to attack the overhead, not just write better prompts.
Better prompts help when the overhead is small. When the overhead is 73%, prompts barely matter.
Most "Claude got dumber" complaints in 2026 trace back to this. The model didn't get dumber. Your overhead grew.
The model has the same compute budget, but most of it is spent re-reading your bloated CLAUDE.md, your 12 hook injections, and the 4 plugins you forgot you installed.
This is the end
The obvious advice "use Haiku for simple tasks, start fresh chats often, batch your questions" is not wrong. It's just operating at the wrong layer.
The real bottleneck is the constant overhead tax that Claude Code pays before every prompt.
Cut the tax, the same plan suddenly has 2-3x more capacity.
Audit tonight. Apply the 9 fixes. Re-run the audit script weekly. Your usage limits will stop biting.
If this saved you a week of Claude limit pain, repost. Part 2 next week: the prompt cache deep-dive — how to measure what's actually being cached vs what's silently re-tokenizing.
*Bookmark this, run the audit weekly until every line is in target
Part 2 next week..
Telegram for daily claude optimization tips: https://t.me/+_ZWrQN7GuDA3ZDEy*
