One "review this repo" turn used 285,000 tokens, according to ComputingForGeeks. That runaway usage and repeated auto-compaction are why some teams report six-figure bills. A small set of habits and a few built-in commands can stop most of the waste and recover 20 to 43 percent of tokens in tested workflows. For you, the practical win is simple: control context, compact deliberately, and batch work so Claude only reads what matters.

Here’s the short answer. Most token waste comes from unmanaged context and blind compaction. If you want immediate savings, treat context as the scarce resource it's and make compaction a deliberate step you control rather than a surprise bill. I’ll save you the trouble: start with /clear and /compact, add a live status line, and set the auto-compact override to 70 percent. Do those four things and you will remove most of the low-effort waste.

Where your tokens go and why compaction hurts

Claude Code counts everything in context. That includes system prompts, the tool manifest and skill cache, every tool call and its full output, the assistant’s internal reasoning, and the visible prose it returns. ComputingForGeeks measured how those shares stack up in an agentic turn. Typical breakdowns were roughly 30 to 50 percent boot and cached system prompt overhead, 30 to 45 percent tool inputs and outputs, 10 to 30 percent reasoning, and 1 to 10 percent visible output.

Long sessions trigger auto-compaction around 187,000 tokens. That compaction step itself can be expensive because it may read the entire history and generate summaries. ComputingForGeeks reported compaction runs that cost 100,000 to 200,000 tokens apiece and called out anecdotal threads describing six-figure bills when that pattern repeated. The expensive loop looks like this: let the history grow, automatic compaction runs, compaction reads everything, compaction generates a long summary, the summary becomes new context, the window fills again. You paid to make more context.

Ten immediate and mid-level moves that save tokens

Several guides converge on the same starter moves. Use /clear to start fresh when you switch tasks so old history isn't reread. Use /compact deliberately before the default auto-compaction threshold so you keep continuity with a short summary instead of letting the system compact blind. Batch small prompts together instead of sending many tiny turns. Limit visible output and stop repeating the same instructions at the start of every session.

Mindstudio.ai and Geeky-gadgets both recommend plan mode. Ask Claude to produce a short execution plan before reading files or running commands so the agent only pulls what's necessary. Geeky-gadgets also compiles practical thread management commands such as /init to create a project blueprint and /resume or /rename to keep conversations tidy.

Mastheads

These small habits reduce how often the agent makes broad, token-heavy reads.

Honestly, for mid- and advanced-level control, cap extended thinking and lower tool verbosity. ComputingForGeeks advised capping extended reasoning so it doesn't swallow 30 percent of an otherwise routine refactor. Lower the auto-compact threshold to 60 or 70 percent of the context window by setting CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70. Add a live status line or use /statusline to monitor context percentage and model costs in real time. Compact on your schedule at 60 to 70 percent to avoid repeated, expensive automatic compactions. For large files, summarize or extract only the relevant functions before asking Claude to act. And use lighter models for routine tasks, reserving heavier capacity for complex reasoning.

Tested gains, tooling, and the trade-offs

ComputingForGeeks ran repeatable benchmarks on an Ubuntu 24.04 VM with Claude Code 2.1.116 and Sonnet 4.5 against a 52-file TypeScript repo. Their numbers showed 20 to 43 percent token reduction using ten open-source tools plus built-in features. That testing setup also illustrated the auto-compaction trap and why deliberate compaction and controlling tool output are high-leverage changes.

Those measured gains are practical, not theoretical. Analytics Vidhya cited a 2025 study showing developers routinely waste thousands of tokens per day when they don't set strict session boundaries. Over 2024-2026, community posts and benchmarks exposed the compaction cost curve and pushed tool builders and power users to publish concrete mitigations. Guides in 2026 moved from high-level advice to exact commands, environment overrides, and tested utilities because users needed reproducible savings.

There are trade-offs. Aggressive compaction can drop ephemeral details that matter later, so teams must decide what to preserve in a concise summary. Deploying sub-agents or parallel workflows speeds iteration but raises tool-call overhead and can increase the token baseline. Geeky-gadgets notes that sub-agents are powerful for scale but should be used sparingly. Some teams accept higher spend for fewer interruptions. The benchmarks show disciplined workflow changes capture most savings with minimal friction, but each team must choose its balance between convenience and cost.

Here are the ten practical moves, compressed into an action list you can apply today: 1) Use /clear when switching tasks. 2) Run /compact manually before the auto threshold. 3) Set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70. 4) Add /statusline or a live status indicator. 5) Batch small prompts. 6) Ask for a short plan before heavy file reads. 7) Limit visible output and trim repeated instructions. 8) Cap extended reasoning and tool verbosity. 9) Summarize or extract relevant functions from large files. 10) Use lighter models for routine jobs and reserve heavy models for complex reasoning. Follow those and your token bill should stop being a mystery.

If you want the fastest win, start a session and run /compact now, add a live status line with /statusline, and set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70 so compaction happens on your terms rather than at the default threshold. Combine that with plan mode before heavy reads and batching prompts and you will see rapid reductions in token usage.

Related Articles

Set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70 and run /compact now.

This article was created with AI assistance.