Claude Code Tokens: How They Work and How to Save 70%

In sintesi

Standard Claude Code sessions waste 40-60% of their tokens on avoidable overhead (redundant context, verbose confirmations, the wrong model for the task)
3 techniques you can use today: Caveman Mode (forces short answers), manual session compaction, picking the right model for each task
Typical savings: 50-70% of tokens with the same output quality
The core problem: Claude sends the entire history with every message, so compact the session every 30-40 messages

Is Claude Code burning through your tokens?

You open Claude Code, start a coding session, and half an hour later you've hit your usage limit. Sound familiar?

It's not your fault. It's the default configuration.

Anthropic optimized Claude for quality, not efficiency. The result: every message drags the full chat history along with it, Opus reasons in depth even on trivial tasks, and responses are padded with pleasantries that eat tokens without adding any value.

In this article I'll explain exactly how the problem works and give you the tools to fix it.

Why your tokens run out so fast

Before we get to solutions, it's worth understanding the mechanism.

The context window is cumulative

Every message you send to Claude isn't processed in isolation: it carries the entire previous conversation with it. This is called the context window, and the longer a chat runs, the more tokens each turn consumes.

A long session with a 5,000-token CLAUDE.md means those 5,000 tokens get loaded before you've typed a single word, on every turn.

Opus is powerful but expensive

Claude Opus, the most capable model, is the default in many workflows. The problem is that it burns hundreds of thousands of tokens even on dead-simple tasks, the kind Sonnet would handle just fine.

According to internal benchmarks, in typical developer sessions:

62.5% of consumed tokens are "waste" (verbosity, pleasantries, excessive reasoning)
37.5% is the content that actually matters

Optimization techniques

1. Caveman Mode: the most viral trick

Caveman Mode is an open source Claude Code skill built by Julius Brussee that makes Claude talk like a caveman. Literally.

Instead of answering with full sentences, long explanations and polite greetings, Claude switches to a telegraphic style: fragments without articles, zero "Great question!", no "Let me know if you need anything else".

# Normal Claude response:
"Sure! I can help you with that. The problem you're 
describing is common in React applications. What 
you'll need to do is update the state like this..."

# Caveman Mode response:
"useEffect cleanup missing. Add return () => clearTimeout(t)"

Benchmarks across 11 real tasks show an average of 294 tokens per response vs 1,214 in normal mode, a 65% drop.

To enable it:

# Install the skill (pick one of the two methods)
claude plugin marketplace add JuliusBrussee/caveman
claude plugin install caveman@caveman

# or via npx
npx skills add JuliusBrussee/caveman

# Turn it on during the session
/caveman
# or type "less tokens please" or "caveman mode"

The interesting part? The code it produces is identical in quality. All you lose is the small talk.

2. opusplan: use Opus only where it counts

The /model opusplan command turns on an automatic hybrid approach:

Opus handles the planning phase (where its deep reasoning is worth every token)
Sonnet takes over in the implementation phase (where speed matters more than depth)

This split mirrors how the human brain works: you think deeply before acting, then you act efficiently.

The estimated savings are significant because Opus costs roughly 3x as much as Sonnet per output token. Using it only for planning, where it really shines, is a smart choice both for cost and for quality.

# Turn on hybrid mode
/model opusplan

# For simple tasks, stay on Sonnet
/model sonnet

# Switch to Opus only for complex architecture/refactoring
/model opus

3. Smart context management

Claude Opus 4.7's 1 million token context window doesn't mean you have to fill it. Quite the opposite.

A few concrete practices:

Use /compact proactively When you notice Claude starting to lose the thread, run /compact. It compresses the conversation history into a dense summary, freeing up tens of thousands of tokens without losing the essential context.

Use /clear between different tasks If you're moving from a feature to a completely unrelated bugfix, a clean session is far more efficient than dragging irrelevant context along.

Optimize your CLAUDE.md A heavy CLAUDE.md costs tokens on every turn. Keep it concise and focused on the core rules, not a full project documentation. Aim to keep it under 2,000 tokens if you can.

# Example of an optimized CLAUDE.md
- Stack: Next.js 14, TypeScript, Tailwind
- Tests: vitest, always write tests for new functions
- Style: functional components, no class components
- Forbidden: console.log in production

4. Cut default verbosity

Claude explains its reasoning in detail. That's useful when you're learning, expensive when you're shipping.

Adding these instructions to your CLAUDE.md cuts response tokens by 30-50%:

# In your CLAUDE.md
## Response style
- Be concise. No explanations unless asked.
- No: "Great! I can definitely help you with that..."
- No: "Let me know if you need any clarification!"
- Yes: get straight to the point
- For code: show the diff, not the whole file

5. Turn off extended thinking for simple tasks

Opus's extended thinking reserves up to 31,999 output tokens for its internal reasoning process. On simple tasks, that's a huge hidden cost.

You can control it in Claude Code settings or via the API:

{
  "thinking": {
    "type": "disabled"
  }
}

Keep it on only for complex architecture, hard debugging, or high-impact decisions.

The full picture: where your tokens go

Here's a realistic breakdown of a 100,000-token session:

Source	Estimated tokens	Optimizable?
Cumulative context window	~40,000	✅ With /compact and /clear
CLAUDE.md per turn	~5,000–15,000	✅ By optimizing the file
Verbose Claude responses	~6,000	✅ With Caveman Mode
Extended thinking	~20,000	✅ By disabling extended thinking
Actual code produced	~15,000	❌ Necessary

With the right techniques, you can bring an equivalent 100,000-token session down to 35,000–40,000, with the same code output.

Summary: the optimal strategy

Default: use Sonnet, not Opus
For planning/architecture: turn on /model opusplan
To cut verbosity: install and use Caveman Mode
Every 30–40 minutes: run /compact
Between different tasks: use /clear
CLAUDE.md: keep it under 2,000 tokens and concise
Extended thinking: turn it off for simple tasks

FAQ

How many tokens can you save with Claude Code? With the techniques in this article the typical saving is 50-70% of tokens for the same code output. A session that would use 100,000 tokens can drop to 35,000-40,000.

How often should you compact a Claude Code session? Every 30-40 messages. Claude resends the whole history with every request, so the longer the session, the more each message costs: compacting shrinks the context without losing the decisions already made.

Should you always use Opus in Claude Code? No. Opus shines at planning and architecture decisions; for writing and running code Sonnet is almost always enough and costs far less. The opusplan mode uses Opus only for the plan and Sonnet for everything else.

Does Caveman Mode make the code worse? No. It shortens Claude's prose replies (from 1,214 to 294 tokens per reply on average in the cited benchmarks), not the code it writes. It removes the noise around the output, not the output.

Resources and further reading

Want to bring these optimizations into your workflow? We're AI consultants for Italian SMBs. Book a free call →