Why Did My AI Coding Bill Spike?

Quick answer
Cost is input tokens times price plus output tokens times price, and agent runs re-send the whole conversation on every step.
A long session is therefore quadratic in cost: each turn pays for everything before it.
The usual culprits are repeated large reads, retry loops, verbose tool output, and turning on a bigger model for the whole session.
Find the expensive action in the usage log before changing your plan; the fix is usually local.
Set a per-task budget and start a fresh session for a new task, so context does not accumulate across unrelated work.

Why does a long agent session cost so much?

Every step sends the conversation so far to the model. If a session grows to tens of thousands of tokens, each additional turn pays for all of them again. The cost curve steepens with session length even when the work per step is small.

Tool output makes it worse. A full test log, a large diff, or a file read of several thousand lines enters the context and is re-sent on every later turn. One accidental read of a generated bundle can dominate the bill.

Which actions usually cause the spike?

Repeated reads of the same large file, a loop retrying the same command, and a session that was left open while a plan changed several times. Also common: a big model selected for routine edits, and a harness configured to send the whole repository index on every turn.

Inspect the usage breakdown rather than the total. Providers report input and output separately, and an input-heavy spike points at context size while an output-heavy one points at long generations.

How do you find the expensive turn?

Look for the step where context size jumps: a large file read, a full test run with verbose output, or a tool that returns a page of JSON. Then check whether that step was necessary or whether a narrower command would have answered the question.

If the harness exposes per-session or per-turn usage, compare a normal task with the expensive one. The difference is usually one action repeated, not a general increase in work.

# Cheaper habits for the same work
# 1. Read a slice, not the file
sed -n '1,120p' src/server/app.ts
# 2. Filter test output to failures and the summary
npm test -- --reporter=dot 2>&1 | tail -40
# 3. Start a new session per task instead of continuing one all day
# 4. Use the smaller model for mechanical edits

What fixes it without slowing the work?

Keep sessions scoped to one task, read the relevant slice of a file instead of the whole thing, and ask for summaries rather than raw output. Reuse a written plan so the agent does not re-derive context after every compaction.

Route routine work to a smaller model and reserve the expensive one for the parts that need it. Set a budget per task and a spend limit for the account; an agent with no ceiling will spend to the limit of its retry behaviour.

Where this bites vibecoders
The classic spike is one cat of a bundled file or a minified dependency during a debugging session, followed by twenty turns that re-send it. Nothing in the conversation looks different; the usage record does. Cap reads and start fresh sessions.

Where AI coding assistants get this wrong

Reading whole large files to answer a small question.
Leaving one session open across unrelated tasks.
Piping verbose test output into the context.
Using the largest model for mechanical edits.
Ignoring a retry loop that burns tokens without converging.
Setting no spend limit on the account.

Checklist

Check input versus output usage first.
Find the turn where context size jumped.
Read slices instead of whole large files.
Collapse tool output to the part that matters.
Start a new session per task.
Set a per-task budget and an account limit.

FAQ

Is output more expensive than input?

Usually yes per token, but agent workloads are often input-heavy because the context is re-sent every turn. Check the breakdown: a spike with normal output and large input points to context growth, not to long answers.

Does a subscription plan remove the risk?

It caps the bill but not the constraint: plans with usage limits will throttle or require an upgrade when a session is expensive. The habits that reduce token use also reduce how often you hit those limits.

Why did the cost rise after I added a skill?

The skill’s description is in context from the start, and its body is loaded when triggered. A large skill that triggers often adds input on many turns. Move reference material into sibling files and keep the loaded part short.

How do I budget an agent task?

Estimate from a similar task you have already measured, set a ceiling, and stop when it is reached. The point is not the exact number; it is noticing a task that is spending far more than its output justifies.