Conversational Development With Claude Code — Part 15: Cost Control and Model Strategy in Claude Code
TL;DR
Controlling cost in Claude Code is not about fear — it is about awareness.
In this chapter, we explore how to read real-time token usage in the CLI, analyze historical consumption with ccusage, strategically select models (Sonnet 4.5, Opus, Haiku), leverage caching to reduce costs dramatically, and understand how authentication method (subscription vs Anthropic Console) changes your pricing strategy.
This is where engineering meets economics.
The hidden dimension of AI-assisted engineering
When you write code, you think about:
- Architecture
- Performance
- Readability
- Scalability
But when you work with large language models, there is a new axis:
Token economics.
Claude Code makes cost visible.
And visibility changes behavior.
Professional engineers do not optimize blindly — they measure first.
Real-time session cost inside the CLI
Claude Code exposes session metrics directly in the terminal.
During an active conversation you can see:
- Total cost in USD
- Input tokens
- Output tokens
- API time
- Wait time
This is not a billing dashboard.
It is immediate operational feedback.
It allows you to:
- Detect runaway context growth
- Stop excessively long sessions
- Decide when to compact or reset
- Evaluate reasoning intensity vs output usefulness
You cannot view past sessions here — but you can control the present one.
And that is often enough.
The power tool: ccusage
If real-time visibility is tactical, ccusage is strategic.
Run it via:
npx ccusage
ccusage parses local Claude Code JSONL files and generates structured reports.
It provides:
- Daily token usage
- Weekly aggregation
- Monthly aggregation
- Session-level breakdown
- 5-hour billing window tracking
- Model-level analysis
- Cache creation vs cache read metrics
- Estimated cost in USD
- JSON export support
This transforms invisible token streams into actionable intelligence.
Example: 19 million tokens for $15.99
In a real scenario:
- ~19,453,000 tokens consumed
- Total cost: $15.99
- Significant portion reused from cache
Without cache, the cost would have been dramatically higher.
This is the engineering lesson:
Context reuse is cost optimization.
Understanding cache economics
Claude Code cache behavior works like this:
- First use of a token → full price.
- Cached storage → full cost for write.
- Future reads → fraction of original price.
This enables:
- Large architectural discussions
- Long-running backend builds
- Multi-session context reuse
- Multi-agent workflows
You pay once for structure.
You reuse cheaply for evolution.
This changes how you design sessions.
Reading ccusage output professionally
A typical ccusage report shows:
| Date | Model | Input Tokens | Output Tokens | Cache Write | Cache Read | Estimated Cost |
|---|
The advanced engineer asks:
- Which model consumed the most?
- Was Opus used unnecessarily?
- Are we overproducing output tokens?
- Is cache reuse effective?
Cost awareness becomes architectural hygiene.
Model selection strategy: capacity vs economics
Claude Code supports multiple models. Each is priced per million tokens.
Sonnet 4.5 (default recommendation)
- $3 / million input
- $15 / million output
- Balanced reasoning depth
- Strong architectural capability
This is the practical default for most serious work.
Opus (deep reasoning)
- $15 / million input
- $75 / million output
- High reasoning ceiling
- Complex system design
- Advanced algorithmic analysis
Use Opus when:
- You are modeling deep architectural transformations
- You need cross-domain reasoning
- You are evaluating large-scale refactors
Do not use Opus for simple formatting or boilerplate.
Haiku (fast & lightweight)
- $1 / million input
- $5 / million output
- Quick tasks
- Simple transformations
- Refactors without deep reasoning
Haiku is ideal for:
- Documentation rewriting
- Small bug fixes
- Syntax adjustments
- Light TypeScript typing
Sonnet 1M context
- $6 / million input
- $22.50 / million output
- Larger context window
- Useful for very large repositories
Use only when context scale demands it.
Choosing models strategically
Think in layers:
- Architecture analysis → Sonnet or Opus
- Feature implementation → Sonnet
- Minor edits → Haiku
- Massive cross-file reasoning → Sonnet 1M or Opus
Model switching is a skill.
Cost control is not about always choosing the cheapest option.
It is about choosing proportionally.
Subscription vs Anthropic Console authentication
Claude Code supports two authentication paths.
1. Claude Subscription
- No per-million-token billing
- Daily usage limit
- Cost invisible, limit visible
In this case, optimization is about:
- Not hitting daily caps
- Managing session length
2. Anthropic Console API key
- Billed per million tokens
- No strict daily cap
- Full cost transparency
In this case, optimization is about:
- Monitoring via CLI
- Tracking via ccusage
- Managing model choice
- Leveraging cache aggressively
Different authentication → different optimization mindset.
Professional workflow for cost control
- Use Sonnet 4.5 by default.
- Escalate to Opus only when reasoning depth requires it.
- Use Haiku for mechanical edits.
- Compact long sessions when context is bloated.
- Monitor real-time session cost.
- Run
ccusageweekly. - Analyze cache effectiveness.
- Adjust model strategy accordingly.
Cost awareness becomes part of engineering discipline.
The economics of context engineering
The deeper insight is this:
Tokens are not just cost units.
They are cognitive bandwidth.
When you:
- Structure prompts carefully
- Avoid redundant restatement
- Use compact intelligently
- Reuse context via cache
You optimize both:
- Cost
- Clarity
Sloppy context design wastes both money and reasoning capacity.
MCP integration and cost
ccusage itself includes MCP support.
It can expose usage metrics as tools within Claude Code.
This means:
Cost analysis can become part of the conversational workflow.
The system can reason about its own consumption.
That is meta-optimization.
Final reflection
AI-assisted development introduces a new professional responsibility:
Economic awareness.
Just as we measure:
- CPU
- Memory
- Latency
- Database queries
We now measure:
- Input tokens
- Output tokens
- Cache reuse
- Model selection efficiency
The mature engineer does not fear cost.
They instrument it.
Have you measured your token usage yet?
How many millions have you consumed?
Which model gave you the best reasoning-to-cost ratio?
Share your numbers and insights in the comments.
Next chapter: advanced multi-model orchestration and reasoning depth strategies.
— Cristian Sifuentes
Full-stack engineer · AI-assisted systems thinker
Top comments (0)