How to cut Claude Code costs by half without doing less

Measure before you optimize

Agent spend is heavily skewed. In most months a handful of long exploratory sessions account for the majority of the total, so optimizing uniformly means spending effort on sessions that cost cents while ignoring the ones that cost dollars.

For scale, Anthropic reports Claude Code averaging about $13 per developer per active day and $150 to $250 per developer per month across enterprise deployments, staying under $30 per active day for 90 percent of users, as of August 2026. If you are far above that band, the cause is almost always one of three things: Opus left as the default, a session nobody ever cleared, or an unsupervised run that kept going.

The eleven changes, ranked

The two that matter most

1. Model routing

Opus 5 costs $5 in and $25 out per million tokens. Sonnet 5 is $3 and $15 from 1 September 2026, and is running at introductory pricing of $2 and $10 through 31 August 2026. Haiku 4.5 is $1 and $5. For a large fraction of real work, the cheaper model produces the same diff.

The useful framing is not "which model is best" but "which model is sufficient for this task". Renaming a symbol across twenty files, writing tests to a stated spec, applying a described refactor: Sonnet and often Haiku do these correctly. Reserve Opus for genuine reasoning, unfamiliar architecture, and bugs that have already defeated one attempt.

# Switch the current session
/model sonnet

# Opus while planning, Sonnet while executing
/model opusplan

# In a subagent definition, front matter:
#   model: haiku

2. Prompt precision

The single most expensive phase of any agent task is orientation: finding the relevant code. It burns turns, and every turn re-sends everything accumulated so far.

Nothing else on this page has that leverage, and it costs you ten seconds of thought. Vague requests like "improve this codebase" trigger broad scanning; specific ones let Claude work with minimal file reads.

Context hygiene

Claude Code sends your full conversation with every request, and each tool call sends another request carrying that batch of results. A one-line question in a session that has been open all day still draws usage for the whole conversation.

1. Clear between tasks. /clear costs nothing and starts a new context. Use /rename first so you can /resume the old one later.
2. Compact with a focus. /compact Focus on the auth bug fix keeps what you choose instead of what the automatic pass guesses. You can also put standing compaction instructions in CLAUDE.md.
3. Delegate the verbose reads. Send test runs, log processing, and documentation fetches to a subagent. The output stays in the subagent context window and only the summary comes back to yours.
4. Keep project memory small. CLAUDE.md loads at session start and is present even when you are doing unrelated work. Anthropic suggests keeping it under 200 lines and moving workflow-specific instructions into skills, which load on demand.
5. Prefer CLI tools to MCP servers where one exists. gh, aws, and gcloud add no per-tool listing at all. Run /context to see what is consuming space and /mcp to disable servers you are not using.

The cache lever nobody uses

Prompt caching is what makes agent sessions affordable: a cache read costs 10 percent of the base input rate, so the repeated prefix on turn thirty is billed at a tenth of what turn one paid for it. Claude Code applies it automatically. The failure mode is the gap.

The practical rule: a session you leave open over lunch and return to is a full context reprocess on the first message back. On a 400K-token context at Sonnet 5 that is roughly a dollar to say "carry on". Two habits fix it.

• Finish or clear before a long break. If the task is done, /clear. If it is not, at least know the first message back is expensive and make it a substantial one.
• Resume from a summary. On Pro and Max, Claude Code offers this when you resume a large session after a long break, so later requests do not carry the full history.

Effort, hooks, and the things that are actually configurable

Turn the reasoning down for routine work

Extended thinking is on by default because it materially improves hard tasks. Thinking tokens bill as output tokens, which are the most expensive category, and the default budget can run to tens of thousands of tokens per request.

# For this session
/effort low

# For one launch
claude --effort medium

# For scripts, overrides everything else
export CLAUDE_CODE_EFFORT_LEVEL=low

# Fixed-budget models only: cap the thinking budget
export MAX_THINKING_TOKENS=8000

Low effort on mechanical work is one of the least painful savings available. Escalate with the ultrathink keyword in a single prompt when one turn genuinely needs it, rather than paying for depth on every turn.

Filter tool output before Claude sees it

Every command the agent runs returns output that becomes input tokens on the next turn. A test suite printing 5,000 lines is a purchase. A PreToolUse hook can preprocess it down to the part that matters.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "~/.claude/hooks/filter-test-output.sh" }
        ]
      }
    ]
  }
}

Anthropic gives the worked example: the script rewrites npm test, pytest, or go test into the same command piped through a grep for failures, turning tens of thousands of tokens into hundreds. Verify it with /hooks, or run claude --debug and look for modified tool input keys: [command].

Watch what parallelism costs

Agent teams spawn multiple Claude Code instances, each with its own context window. Anthropic puts them at roughly seven times the tokens of a standard session when teammates run in plan mode. Keep teams small, use Sonnet for teammates, keep spawn prompts focused, and shut teammates down when their work is finished, because each one keeps consuming until it exits.

What not to bother with

• Shortening your own prompts. Your words are a rounding error next to file contents and tool output. Be precise, not brief; they are different things.
• Disabling caching. Caching is what makes long sessions affordable. There is no version of this that saves money.
• Chasing background token use. Conversation summarization and status checks typically cost under $0.04 per session. Not where your money is.
• Avoiding the agent for real work. If a $2 session replaces an hour, it was the cheapest thing you did that day. Cost control means removing waste, not removing use.

Questions people ask

Keep reading