You keep running out of Claude tokens not because you're doing too much, but because of a hidden multiplier: roughly 96% of every token you send is "reused input" — old conversation the model re-reads on every single turn. The fix is not a bigger context window (Claude Opus 5 and Sonnet 5 already give you 1 million tokens) or a higher subscription tier. It is cleaning your AI desk: trimming what you send, compressing what you keep, and stopping waste before it hits the model. The 15 habits below — ranked from zero-effort to advanced-engineering — cut our own tracked token consumption by up to 80% on a single working day.
Last verified: 2026-07-29 TL;DR:
- The message you type is the smallest part of every API call — the rest is re-sent conversation history, system prompts, and tool definitions.
- A typical multi-server Claude Code setup burns ~55,000 tokens in tool definitions before you type anything. [ClaudeMeter]
- Prompt caching cuts input costs up to 90% and latency up to 85% for repeated context. [Anthropic]
- Claude's 1M-token context window is no longer beta-gated, but research shows only ~50-65% of it is "effective" — context rot is real. [MorphLLM]
- The single highest-leverage habit: start a new thread when the job changes. It stopped the biggest measured token waste in our testing.
Why You Hit the Limit (The Math Nobody Explains)
Every time you press Enter in Claude (or ChatGPT, or any LLM), the entire conversation — system prompt, tool definitions, every previous message, every previous answer — gets wrapped up and sent from the top. The model has no memory between calls; it fakes memory by re-reading everything. This means your tenth message costs your new prompt plus the nine previous exchanges. By message 30, what you just typed is a rounding error against the accumulated transcript.
Here is the compounding pattern:
| Turn | What gets sent |
|---|---|
| Message 1 | Your prompt only |
| Message 2 | Your prompt + answer 1 + your first prompt |
| Message 10 | Your prompt + all 9 prior Q&As |
| Message 30 | Your prompt + 30 prior Q&As + tool results + system overhead |
The old material has a name: reused input. It is the part of every request the model has already seen. In one tracked working session — 143 separate Claude Code threads in a single day — we measured 3.77 billion tokens moving through the workspace. Of those, 3.59 billion (≈96%) were reused input. Nobody types 3.77 billion tokens. You type a few thousand, and the platform silently resends the rest on every turn.
The labs will not fix this for you. Their incentive is to have you using their compute, and a larger context window (which Claude now offers at 1M tokens, generally available since March 2026 [Anthropic support docs]) makes the problem worse, not better: more capacity means you can pile more onto the desk, and you hit the wall faster because total tokens grow, not shrink. Reducing your token consumption is your responsibility — it's your desk, and you have to own it.
How Big Is the Hidden Floor (Claude Code)?
Before you type a single word, a stock Claude Code session already consumes roughly 7,850 tokens of overhead: 4,200 for the system prompt, 680 for auto-memory, 280 for environment info, 120 for the MCP tool index, 450 for skill descriptions, plus your global and project CLAUDE.md files. [ClaudeMeter, verified 2026-05-10; Anthropic simulator]
That is the clean install. Connect a few MCP servers eagerly — GitHub, Slack, Sentry, Grafana — and tool definitions alone push the floor to roughly 55,000 tokens. The GitHub MCP server by itself accounts for about 46,000 tokens, roughly 22% of a 200K context window. [GitHub issue #525, anthropics/claude-agent-sdk-python; Anthropic Engineering]
Anthropic now auto-enables MCP Tool Search when eager-loaded tool definitions would exceed 10% of the context window (above 20,000 tokens), which keeps the worst case off most clean installs. But three things bypass that guardrail: ENABLE_TOOL_SEARCH=false, an older Claude Code release, or a single MCP server that ships its full schema as a non-search payload. Stack a few and you can land at 100,000+ tokens of overhead — half the window — before the conversation starts.
Level 1 — Clean Your Own Desk (9 Habits Anyone Can Use)
These cost nothing, need no install, and work on any AI tool. They are ranked by measured token impact.
Habit 1 — Start a clean thread when the job changes (biggest single win)
Long conversations are efficient while you are focused on one problem and very expensive the moment the task shifts. Each new message in an old thread carries every prior token with it — you can be dragging 50,000, 100,000, or a million tokens of now-irrelevant context into a question that needs almost none of it.
In our testing, starting a fresh thread when the job changed produced the largest measured reduction in daily token consumption. A clean task does not report zero — Claude Code still sends its ~7,850 tokens of starting instructions — but it stops the old conversation from riding along. You do not throw the prior task away; you just stop making the next job carry it.
Habit 2 — Edit your prompt instead of correcting the model
If your original prompt was unclear or had a typo, do not type "no, that's not what I meant" as a new message — that adds another full turn on top of the already-large transcript. Hit the edit button. Fix the original request and resend. The model re-processes from the corrected point, and you avoid stacking a wasted bad answer plus a correction into your running history. Almost nobody does this, and it compounds fast.
Habit 3 — Ask only for the answer you need, and name the format
Output costs you twice: once when it is generated (expensively), and again on every subsequent turn because it becomes input. Asking for "a 50-page deep research paper" when you need five bullets is the most common silent waste. If you need JSON, ask for JSON. If you need 150 words, say so. Specifying "List 3 features as JSON with keys: name, benefit, priority" produces shorter, cheaper, more parseable output than "describe the three most important features in detail." Research on this pattern shows output token reductions of 30-50% for equivalent informational content. [Nanonets]
Habit 4 — Bundle related questions and specify the output shape
If you have three questions from the same document, put them all in one query instead of three separate turns. Each separate turn re-sends the full transcript plus the source. Bundle them, then specify what you want: a one-pager, bullets, a headline — naming the format reduces ambiguity the model would otherwise spend tokens disambiguating.
Habit 5 — Carry the result, not the argument
For multi-step work (research → document → review), do not carry the entire transcript from step one into step two. Take the artifact that step one produced — a research summary, a draft — and start the next stage from that result alone. You don't need your bad first draft, three rounds of criticism, the sources you rejected, and the model's reasoning stacked into the next call. Keep the result. Move on. Keep the desk clean.
Habit 6 — Send the lightest useful form of the source
If the words matter and the layout does not, convert your source to text or markdown before pasting it in. Do not upload a 40-page PDF just because it came to you as a PDF. Do not attach 18 screenshots when a text extract of the relevant section works. The model can parse all of it — but it will eat your token budget fast. Taking two minutes to convert a PDF to markdown and paste in only the relevant section is dramatically cheaper than dumping the whole file.
Habit 7 — Search the file yourself, don't make the model search it
Yes, Claude can read and search entire files now. It is also a massive token burner. Be in a position to say: "I searched it. Here are the relevant passages. Focus on these." Snippets cost tokens; whole files cost tokens on every turn that follows.
Habit 8 — Keep answers you'll need again in a retrievable place
If you're working around the edges of a problem across multiple conversations, store the accepted answers in a database, notes app, or knowledge base you can look up quickly. The cheaper you make retrieval, the more you save: instead of re-deriving the same answer across three threads (each time paying for the full derivation), you look it up once and hand the result in. This is the principle behind personal knowledge tools and scratchpads — saving context outside the window so the agent (or you) doesn't re-pay for it.
Habit 9 — Load only the tools the job can use
Every connected tool carries a description — what it does, when to use it, what arguments it takes — and that description is model input before the model does anything. A typical multi-server setup burns ~55,000 tokens in tool definitions before Claude processes your first word. [ClaudeMeter]
Anthropic's own engineering guidance is blunt: bloated tool sets with overlapping functionality create ambiguous decision points — "if a human engineer can't definitively say which tool should be used in a given situation, an AI agent can't be expected to do better." [Anthropic Engineering] The fix: curate a minimal viable set of tools. In six to eight months, models may auto-select the right toolset; today, they don't reliably.
Level 2 — Let Software Keep the Desk Clean
The nine habits above work, but they require discipline you will not always have. You'll forget to start a new thread, you'll paste a PDF because it's faster, and you'll ask for a 50-page paper when you needed bullets. Level 2 is automating the tedious parts of Level 1.
Habit 10 — Use context-editing and compaction when you can't start clean
Sometimes starting a fresh thread is not practical — you're mid-debug, the model needs a decision, and restarting would lose the state. That's where compaction and context editing come in.
Anthropic supports compaction (the compact_20260112 edit in the SDK) for long-running work: it summarizes your conversation history, replaces the full transcript with that summary, and lets Claude continue on tasks that would otherwise exceed the context window. [Anthropic platform docs] Claude Code exposes this as the /compact command, which compresses history in place by roughly 40-50%. [Token Limits]
A caveat: compaction is lossy. One documented failure mode: after compaction, an assistant believed the user was running "Open WebUI, can't modify" when they had just been editing their custom UI together — the summary captured stale context. [GitHub issue #22467] The lesson: compaction is a whole lot better than hitting a wall, but it is an approximation, not a perfect replay.
Habit 11 — Use compaction-aware workflows and know the two meters
Claude Code tracks two separate constraints that look at the same input from two angles. The 200K (or 1M) context window is a hard ceiling on a single turn — exceed it and Claude compacts or truncates, visible via /context. The rolling seven-day quota is a utilization fraction computed server-side — exceed it and you get a 429. Cache-miss turns (model switch, /compact, MCP toggle, TTL expiry) re-bill the overhead at full cache-write rate. The two meters fail differently and the fix is different for each. Knowing which one you are hitting is half the battle. [ClaudeMeter]
Habit 12 — Pick the dumbest model that can still do the work
For a serious task, use the absolute dumbest model that will still get the job done. As of July 2026, on the Anthropic API that ladder looks like this:
| Model | Context window | Input / MTok | Output / MTok |
|---|---|---|---|
| Claude Opus 5 | 1M | $5 | $25 |
| Claude Opus 4.8 (legacy fallback) | 1M | $5 | $25 |
| Claude Sonnet 5 (intro through Aug 31 2026) | 1M | $2 | $10 |
| Claude Sonnet 5 (standard, from Sep 1 2026) | 1M | $3 | $15 |
| Claude Haiku 4.5 | 200K | $1 | $5 |
[Anthropic platform pricing docs; aipricing.guru]
Haiku 4.5 at $1/$5 per million tokens is 5x cheaper on input and 5x cheaper on output than Opus 5. For repetitive work — classification, extraction, simple edits — routing to Haiku instead of Opus cuts cost by 80% with no loss of quality on those tasks. The more you work with AI, the better your feel for where that "dumbest model still gets it done" line sits; the habit is to explicitly consider it, not default to the most capable model.
Level 3 — Stop the Mess Before It Reaches the Model
Levels 1 and 2 share a single ceiling: by the time the model reads your skill or your compaction rule, the initial request (system prompt, tool definitions, hidden setup) has already been sent. Level 3 hooks the request before it ever leaves your machine.
Habit 13 — Use prompt caching (the biggest API-level win)
Prompt caching lets Claude store and reuse frequently accessed context between API calls — large documents, instructions, or examples — without re-sending the same information with each request. It is an API feature, not a chat-app feature, and it is the single biggest cost lever for repeated work.
The numbers, from Anthropic's own docs: up to 90% cost reduction and up to 85% latency reduction for long prompts. [Anthropic, March 2025]
| Cache operation | Multiplier vs. base input | Notes |
|---|---|---|
| 5-minute cache write | 1.25x | Pays off after 1 read |
| 1-hour cache write | 2x | Pays off after 2 reads |
| Cache read (hit) | 0.1x | Same duration as the preceding write |
[Anthropic platform pricing docs]
Cache reads bill at 10% of the base input rate; cache writes are 25% more expensive than uncached input. The first cold turn of a session pays full price on the overhead; the next handful of warm turns pay a tenth of it. The five things that invalidate the cache (model switch, /compact, MCP toggle, TTL expiry, and any edit to the cached prefix) are worth memorizing because each one restarts the cold-turn cycle. Cache-aware rate limits also mean prompt cache read tokens no longer count against your Input Tokens Per Minute limit, so caching isn't just cheaper — it's higher throughput.
If you are doing any kind of repeated API work with stable context (system prompts, tool libraries, knowledge bases), prompt caching is non-negotiable. If you're only using a chat interface and don't touch the API, you don't need it — focus on the Level 1 habits instead.
Habit 14 — Use an intermediary proxy to enforce hard limits and refuse calls
If you want to say "never send more than N tokens out" or "never get back more than M tokens," you cannot do that from inside a conversation. You need an intermediary that sits between your AI and the model provider and can return an answer without a model call (when the answer is already known), run a fixed local recipe with no model call, select only the useful passages to forward, forward a small request under hard caps, or stop the request entirely.
Anthropic's own engineering blog describes the right framing: "Just-in-time" context — the agent maintains lightweight identifiers (file paths, stored queries, web links) and dynamically loads data at runtime via tools rather than embedding everything up front. Claude Code already does this with targeted Bash commands (head, tail) to analyze large data without loading full objects into context. [Anthropic Engineering] The principle extends to any proxy that can hit your knowledge base, find an accepted answer, and return it without a model call — saving you the entire 100% of the call.
Habit 15 — Write context, don't stuff it
The umbrella habit underneath all of Level 3 is context engineering — the discipline Anthropic defines as "curating and maintaining the optimal set of tokens during LLM inference." It is the natural progression of prompt engineering: the question is no longer "what is the perfect prompt" but "what configuration of context is most likely to generate the model's desired behavior?" [Anthropic Engineering]
Two principles from that body of work are worth memorizing:
- Context rot is real. As token count increases, the model's ability to accurately recall information decreases. Transformers attend pair-wise across all n tokens — n² relationships for n tokens — and attention stretches thin as n grows. Research from NVIDIA (RULER), Adobe (NoLiMa), and Chroma shows that advertised context and effective context differ: roughly 50-65% of the window is "effective" before degradation sets in. [MorphLLM, verified July 2026] A 200K window filled with precisely relevant code outperforms a 1M window filled with an entire repository.
- Find the smallest high-signal set. Anthropic's own guidance: "Good context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome." Minimal is not the same as short — it is the minimal information that fully outlines expected behavior, organized with structure (XML tags, markdown headers) so the model can parse it.
What this means for you
If you only do one thing: start a new thread when the job changes. It's free, it takes two seconds, and it produced the biggest measured token reduction in our testing.
If you use the API at all: turn on prompt caching. 90% input cost reduction on repeated context is not a marginal optimization — it's the difference between a workflow that runs daily and one you can't afford.
If you're spending real money on agents: audit your tool definitions. A five-server MCP stack can quietly cost you 55,000 tokens of overhead per cold turn, billed against both your context window and your weekly quota. Trim to the minimal viable tool set, use deferred tool loading, and put the dumbest model that works on the repetitive tasks.
The instinct that bigger context windows will fix this is wrong. More capacity means you can pile more onto the desk — and you hit the wall faster. The truth is boring and it has always been boring: keep your desk clean.
FAQ
Q: What is the quickest fix when Claude says "usage limit reached"? A: Start a fresh thread. Long conversations carry every prior token forward — a new thread drops the reused-input overhead to near zero (modulo the ~7,850 tokens of Claude Code starting instructions). This is free and takes two seconds. [ClaudeMeter]
Q: Does Claude's 1M token context window solve the limit problem? A: No. The 1M window is generally available since March 2026 on Opus 5, Sonnet 5, and Fable 5, but research shows only ~50-65% of it is "effective" before context rot sets in. [MorphLLM] A bigger window lets you pile more on the desk — and you hit the wall faster, not slower, because total tokens grow.
Q: How much does prompt caching actually save?
A: Up to 90% on input cost and up to 85% on latency for long, repeated prompts, per Anthropic's own benchmarks. Cache reads bill at 10% of the base input rate; cache writes are 25% more expensive than uncached input. The five cache-invalidation triggers are: model switch, /compact, MCP toggle, TTL expiry, and any edit to the cached prefix. [Anthropic]
Q: How many tokens does Claude Code burn before I type anything? A: Roughly 7,850 tokens for a stock install (system prompt + auto memory + environment + MCP index + skills + CLAUDE.md files). With eagerly-loaded MCP servers — say GitHub, Slack, Sentry, Grafana — tool definitions alone push the floor to ~55,000 tokens. A heavier setup can reach 100,000+. [ClaudeMeter, verified 2026-05-10]
Q: Is /compact safe to use?
A: It's a whole lot better than hitting the wall, but it's lossy. It rewrites your history in a more concise format — roughly 40-50% compression — but documented cases exist where the summary captures stale context and the model loses track of what was actively being worked on. Use it when you can't start a fresh thread; expect to re-orient the model afterward. [Token Limits; GitHub issue #22467]
Q: Which Claude model should I use to save tokens? A: Use the dumbest model that can still do the work. As of July 2026, Haiku 4.5 ($1/$5 per MTok in/out, 200K window) is 5x cheaper than Opus 5 ($5/$25, 1M window) on both input and output. Route repetitive tasks (classification, extraction, simple edits) to Haiku and reserve Opus for reasoning-heavy work. [Anthropic pricing docs]
Discussion
0 comments