Conversational Development With Claude Code — Part 15: Cost Control and Model Strategy in Claude Code
Source: Dev.to
Real‑time Cost Visibility in Claude Code
Controlling cost in Claude Code is not about fear—it is about awareness.
Claude Code makes token usage visible directly in the terminal, providing immediate operational feedback that lets you:
- Detect runaway context growth
- Stop excessively long sessions
- Decide when to compact or reset a session
- Evaluate reasoning intensity versus output usefulness
During an active conversation you can see:
| Metric | Description |
|---|---|
| Total cost (USD) | Current session cost |
| Input tokens | Tokens sent to the model |
| Output tokens | Tokens returned by the model |
| API time | Time spent in the API call |
| Wait time | Time waiting for a response |
This is not a billing dashboard; it is tactical, real‑time insight that helps you manage the present session.
Strategic Usage Analysis with ccusage
While real‑time visibility is tactical, the ccusage tool provides strategic, historical analysis.
npx ccusageccusage parses local Claude Code JSONL files and generates structured reports, including:
- Daily, weekly, and monthly token aggregation
- Session‑level breakdowns
- 5‑hour billing‑window tracking
- Model‑level analysis
- Cache‑write vs. cache‑read metrics
- Estimated cost in USD
- JSON export support
Example Report
| Date | Model | Input Tokens | Output Tokens | Cache Write | Cache Read | Estimated Cost |
|---|---|---|---|---|---|---|
| 2024‑02‑20 | Sonnet 4.5 | 12,345,678 | 7,108,322 | 3,210,000 | 2,500,000 | $12.34 |
| 2024‑02‑21 | Opus | 4,567,890 | 2,345,678 | 1,200,000 | 800,000 | $8.90 |
| … | … | … | … | … | … | … |
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 demonstrates that context reuse is a primary cost‑optimization technique.
Cache Behavior
Claude Code’s cache works as follows:
- First use of a token – full price.
- Cache write – full cost for storing the token.
- Future reads – only a fraction of the original price.
This enables:
- Large architectural discussions
- Long‑running backend builds
- Multi‑session context reuse
- Multi‑agent workflows
You pay once for the structure and reuse it cheaply for subsequent evolution.
Model Pricing and Selection
Claude Code supports several models, each priced per million tokens:
| Model | Input ($/M tokens) | Output ($/M tokens) | Typical Use Cases |
|---|---|---|---|
| Sonnet 4.5 | $3 | $15 | Balanced reasoning depth; strong architectural capability; default for most serious work |
| Opus | $15 | $75 | Deep architectural transformations; cross‑domain reasoning; large‑scale refactors (avoid for simple formatting) |
| Haiku | $1 | $5 | Quick tasks, simple transformations, refactors without deep reasoning |
| Sonnet 1M (large context) | $6 | $22.50 | Very large repositories; when context scale demands it |
Layered Thinking
- Architecture analysis → Sonnet 4.5 or Opus
- Feature implementation → Sonnet 4.5
- Minor edits → Haiku
- Massive cross‑file reasoning → Sonnet 1M or Opus
Model switching is a skill; cost control is about choosing the proportionally appropriate model, not always the cheapest one.
Authentication Paths and Their Impact
Claude Code offers two authentication methods, each influencing optimization strategy:
| Authentication | Billing | Daily Limits | Optimization Focus |
|---|---|---|---|
| Subscription (no per‑million token billing) | Cost invisible, daily usage limit visible | Avoid hitting daily caps; manage session length | Monitor via CLI, track with ccusage, manage model choice, leverage cache aggressively |
| Anthropic Console (billed per‑million tokens) | Full cost transparency | No strict daily cap | Same monitoring tools, but emphasis on cost reduction through model selection and cache usage |
Practical Recommendations
- Default to Sonnet 4.5; switch to Opus only when deeper reasoning is required.
- Use Haiku for mechanical edits and quick transformations.
- Compact long sessions when context becomes bloated.
- Monitor real‑time session cost in the terminal.
- Run
ccusageweekly to analyze trends and cache effectiveness. - Adjust model strategy based on the insights from both real‑time and historical data.
Engineering Discipline: Token Economics
Tokens are not merely cost units; they represent cognitive bandwidth. By:
- Structuring prompts carefully
- Avoiding redundant restatement
- Using compact phrasing
- Reusing context via cache
you optimize both cost and clarity. Sloppy context design wastes money and reasoning capacity.
ccusage also includes MCP support, allowing usage metrics to be exposed as tools within Claude Code. This enables the system to reason about its own consumption—a form of meta‑optimization.
Just as engineers measure CPU, memory, latency, and database queries, we now measure:
- Input tokens
- Output tokens
- Cache reuse
- Model‑selection efficiency
The mature engineer does not fear cost; they instrument it.
Closing Thought
Have you measured your token usage yet? How many millions have you consumed, and 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.