How to keep AI coding costs from running away mid-project

A few weeks ago, a fintech startup called Slash made headlines when a developer accidentally burned through $81,000 in AI tokens building a meme-inspired video game. The developer, who had been encouraged by his employer to experiment with vibe coding, underestimated how expensive it is to repeatedly ask Claude to read and rewrite large amounts of code.

"This was a genuine accident, I underestimated my own ability," the developer posted on X. It's a sympathetic situation — and increasingly a common one as AI coding agents move from novelty to daily workflow.

This guide covers the five highest-leverage habits that keep costs predictable.

1. Match the model to the task

The single biggest lever on cost is model selection. Frontier models (Claude Opus, GPT‑5, Gemini Ultra) can run 10–50× more expensive per token than smaller-tier models with acceptable quality for most tasks. Not everything needs the frontier.

A rough mental map:

• Small, fast models (Haiku, Flash, mini): autocomplete, short edits, renaming, boilerplate generation, answering quick syntax questions
• Mid-tier models (Sonnet, GPT-4.1): most coding tasks — implementing a feature from a clear spec, writing tests, reviewing a diff
• Frontier models (Opus, Fable 5, GPT-5): complex architectural decisions, long multi-file rewrites, debugging gnarly production issues, agentic sessions where the model needs to reason across many tool calls

If you're using Claude Code with a Max or Pro plan, the Auto mode routes to the right tier automatically based on detected task complexity — and doesn't count against your token budget the same way API calls do. Switch to Auto as your default and only override when you know you need more power.

2. Plan first, build second

The most expensive AI coding pattern is jumping straight into "rewrite this file" on a large codebase. When the model reads all that context, proposes changes, gets corrections, and iterates, token usage compounds fast.

Claude Code's Plan mode costs a few hundred tokens: you describe what you want, the model proposes a step-by-step approach, and you correct the plan in plain English before a single file is touched. A wrong 400-line diff costs thousands of tokens to fix — and often requires another round to fix the fix.

For anything touching more than two or three files, the sequence is:

1. Describe the goal in /plan
2. Read and correct the plan
3. Execute on the corrected plan

This one habit alone consistently cuts per-feature costs by 30–50% for teams that adopt it.

3. Scope your context window

AI models charge per token — both what you send (input) and what they generate (output). A common mistake is sending the model the entire codebase when it only needs one module.

Practical techniques:

• Be explicit about what to read. Instead of "refactor the auth system," say "refactor src/auth/session.ts — ignore everything else."
• Use --include flags. In Claude Code, --include scopes file reads so the agent doesn't wander into unrelated parts of the repo.
• Let /compact do its job. When a session grows long, Claude Code's context compaction (triggered automatically or with /compact) replaces conversation history with a focused summary, cutting token load by 60–80% while preserving the decisions that matter.

The rough rule of thumb: one token per four characters of English or code. Before kicking off a long agent session on a large file, estimate whether the context fits your budget. If the target file is 2,000 lines (~8,000 characters, ~2,000 tokens), you have room to work. If you're handing it a 50,000-line monorepo module, you'll want to scope it down.

4. Know what burns the most tokens

Not all AI coding tasks are equal in cost. From most to least expensive:

1. Agentic sessions with many tool calls — the model reads files, writes files, runs tests, reads the output, and iterates. Every step is billed.
2. Large file rewrites — reading + generating large diffs compounds fast.
3. Iterative debugging loops — error, fix attempt, new error, repeat.
4. Single-shot generation from a tight spec — cheapest. The model reads the spec and writes the thing once.

For debugging sessions, give the model the error message and the specific function it originated from — not the full stack, not the entire module. For rewrites, break large tasks into smaller, independently-verifiable units.

5. Set real spending limits before you start

After June 15, 2026, Claude Code's agent and headless (claude -p) usage bills against a separate credit pool from interactive chat: $20/month on Pro, $100/month on Max 5×, $200/month on Max 20×. If you're building automations or scheduled agents, that pool can drain faster than you expect.

To stay in control:

• Set the CLAUDE_MAX_COST_PER_SESSION environment variable (or the equivalent in Cursor's settings) as a per-session cap.
• In the Anthropic console, set monthly spend alerts at 50% and 90% of your budget so you get email warnings before you hit the ceiling.
• If you're building a product on top of the API, add token-budget checks in your agent loop and bail gracefully when you exceed your per-run limit.

The Slash developer's $81,000 run happened without guardrails. With a $500 monthly cap set in Slash's API account, the damage would have been a blocked session and a quick conversation — not a viral story.

Putting it together

None of these habits requires slowing down. The developers who use AI coding agents most efficiently tend to share one trait: they think for thirty seconds about what they actually need the model to do before starting the session. That small pause — choosing the right model, scoping the context, running Plan mode first — is what separates a $5 feature from a $50 one.