Cutting Your AI Coding Bill in Half: A Cost-Optimization Playbook

If your monthly AI coding bill looks like a mortgage payment, you're running Opus where Sonnet would do, letting tool loops run unchecked, and ignoring prompt caching. Those three things alone account for most of the waste I see in senior developers' workflows.

Cutting the bill in half is not about using less AI — it's about using the right AI in the right pane. Here's the playbook I've used to roughly halve my monthly cost without losing output.

Where the money actually goes

Before optimizing, know where you're spending. Most senior developers I know are surprised at the breakdown when they check. A typical month looks something like:

• Driver-pane (Opus) tokens: 50-60% of the bill.
• Implementer tool-call tokens: 20-25%.
• Backfill / test tasks: 5-10%.
• Everything else: 10-15%.

The biggest lever is not cutting tokens uniformly. It's moving the right work from expensive models to cheaper ones.

Lever 1: Tier your models by pane

The cost-per-token of Sonnet is roughly a third of Opus; Haiku is roughly a tenth. Most of what you do in Opus today will work in Sonnet. Most of what you do in Sonnet for mechanical work would work in Haiku.

My rule:

• Driver pane: Opus. Worth it.
• Implementer panes with clear specs: Sonnet.
• Test authoring, small refactors, doc updates: Sonnet or Haiku.
• Running the tests and reacting to output: Haiku or a non-Claude CLI.

Moving two of four panes from Opus to Sonnet is approximately a 40% overall bill cut. That's before any other optimization. See Claude vs Codex vs Qwen for the cross-provider tiering.

Lever 2: Use non-Claude CLIs for the cheap work

Qwen and Kimi are 5-10x cheaper than Claude on comparable tasks. They can't replace Claude for judgment, but they can absolutely replace Sonnet for:

• Writing tests for a well-understood module.
• Running routine migrations.
• Updating docs.
• Porting code between frameworks once a pattern is established.

In my grid, the Backfill pane is always Qwen. That pane used to be Sonnet; the quality difference on backfill work is small and the cost difference is large. More in Qwen and Kimi as a local-ish backup.

Lever 3: Tool-call discipline

A Claude session that reads twenty files "just to be sure" before doing any work burns serious tokens. Two habits cut this:

Scope with CLAUDE.md. Tell the agent which directories matter, which to ignore, and which files are authoritative references. A good context file reduces unnecessary reads by a meaningful margin.

Interrupt early. If you see the agent starting a reconnaissance spiral — reading file 5, 6, 7 of a tree it already understands — cut it off and say "skip the exploration, here's what you need."

Over a month of work, these two habits alone save me more than any single model downgrade.

Lever 4: Prompt caching, used correctly

Anthropic's prompt caching is huge for agentic workflows because most of your context repeats across turns. A 1MB CLAUDE.md + project files, cached correctly, costs a fraction of re-sending it every turn.

The mistake I see people make is not structuring prompts to be cache-friendly. A few rules:

• Put stable content (context files, system prompt) first.
• Put volatile content (the latest message, new tool outputs) last.
• Don't edit stable content mid-session — it invalidates the cache.

If your workflow is long conversations with lots of context, caching should cover 60-70% of your input tokens at the lower cached rate. If it's not, check your prompt structure.

Lever 5: Shorter sessions, cleaner context

Long sessions accumulate context that gets re-sent on every turn. At some point, the right move is to start fresh with a summary: "Here's what we accomplished, here's the next step."

I aim for session turnover every 30-60 minutes of active work. Longer than that and the input tokens per turn bloat and the agent's performance actually degrades (too much context to search through).

Lever 6: Kill the runaway loop

Every agentic workflow occasionally gets into a loop: the agent edits, tests fail, it edits again, tests fail again, infinite. If you don't catch it in 30 seconds, you've just burned $5 on nothing.

Two guardrails:

• Keep a shell pane open. You need to be able to kill the process fast.
• Set a mental timer. If an implementation loop takes more than 3 iterations, intervene. Something's wrong with the spec or the environment.

A grid terminal with per-pane kill buttons makes this almost free. Read more at the parallel AI coding workflow post and background AI agents.

Lever 7: Match model to task size

Asking Opus to "add a null check" is waste. Asking Haiku to "redesign the caching layer" is also waste (different kind). Match the model to the task:

For tasks that fit the top two rows — which is most tasks, honestly — using Opus is like hiring a senior architect to write a for-loop.

Lever 8: Avoid redundant review rounds

I used to have Opus write code and then have Opus review its own code in a second pane. It works, but it's expensive. Better: Opus writes, Sonnet reviews. Or Opus writes, and I review. Review doesn't need the top model most of the time.

For the comparative workflow, see multi-model code review — the trick there is that three cheaper models reviewing often beats one expensive model.

A sample budget

Here's a sample monthly budget for a senior dev running four panes daily:

• Opus driver: moderate, because most of the context is cached.
• Two Sonnet implementers: small each, because tasks are well-specced and tool-use is disciplined.
• Qwen backfill: minimal.

Compared to an "all Opus" baseline, this setup is usually around 40-50% of the cost for comparable output. Your ratios will differ; the shape is typical.

Habits vs one-shot fixes

Cost optimization is habits, not settings. The developers I see with the lowest bills share a few:

• They read the cost dashboard weekly, not monthly.
• They interrupt agents aggressively when something looks wrong.
• They keep CLAUDE.md files tight and current.
• They use the cheapest model that works, not the most impressive one.
• They don't run agents when they're not at the keyboard. A background agent is an ongoing cost.

Configure once and the cost creeps back. Habituate and it stays down.

Setup tips for the grid

A grid terminal helps with cost in ways that aren't obvious until you use one:

• You see all four panes' activity at once, so runaway loops are harder to miss.
• Per-pane model assignment makes tiering easy.
• Per-pane kill is one click.
• The cost of the fifth pane is cognitive, not financial, which is a healthy constraint.

See the grid layouts docs for specific layouts, or the parallel AI agents use case for how model tiering maps to panes.

Key takeaways

Halving your AI coding bill doesn't require a new provider or a clever trick. It requires model tiering (Opus only where it matters), non-Claude CLIs for cheap work (Qwen/Kimi), prompt-cache-friendly context, tool-call discipline, and aggressive interruption of runaway loops.

Cost-optimization is a byproduct of good workflow design. Set up the grid right, keep the context files tight, and the bill takes care of itself. The flip side is also true: a messy workflow costs you money even when you're trying to be careful.