Short answer
The true cost of AI coding is mostly not tokens. Anthropic puts average enterprise Claude Code spend at about $13 per developer per active day. The bigger costs are human review, rework from bugs that escape, and long agent runs that re-read the same context. Cut those and the token bill falls too.
Finance asks a simple question about AI coding tools: what do they cost per developer? Engineering answers with a subscription price or a token bill, and both sides feel they have the number.
They don’t. The subscription is the visible line. The real bill sits in places no AI invoice shows: hours of review, bugs that come back a week later, and agent runs that go on for hours because nothing told them to stop. If you budget only the tokens, you will optimise the cheapest part of the system.
What people mean by the cost of AI coding
The direct cost comes in two shapes.
Seats. Claude Code is available on Claude subscription plans (Pro, Max, Ultra, Team, Enterprise), where usage draws from an allowance that resets on a five-hour and a weekly window. Codex is included in ChatGPT plans from Free up to Enterprise, with allowances per five hours and per week, and credits once you go past them.
Tokens. On an API key or a cloud provider, both tools bill per token at API rates. Long context, heavy reasoning effort and parallel agents all push that up.
For a sense of scale, Anthropic’s cost docs say the average enterprise deployment of Claude Code runs about $13 per developer per active day, $150 to $250 per developer per month, and below $30 per active day for 90% of users. That is real money across a team, but put it next to what an engineer’s day costs and it is a small fraction. Which raises the obvious question: where is the rest?
Why tokens are the small line on the bill
The expensive parts of software delivery are human hours, and AI moves them around rather than removing them. The clearest data on this comes from Faros AI’s study of about 10,000 developers. Teams with high AI adoption completed more tasks and merged far more pull requests. They also paid for it downstream.
Review time per pull request up 91%. Pull requests 154% larger. Those hours are paid at an engineer’s rate, not a token rate. DORA’s 2025 report reached a similar conclusion from a different angle: AI amplifies what a team already does, so throughput goes up and so does instability. Instability has a price too: incidents, rollbacks, and the time to find out what went wrong. More on that in code review is the new bottleneck.
There is a quieter cost as well. In METR’s randomised trial, experienced open-source developers were 19% slower with AI tools allowed, while believing they were about 20% faster. A team that feels faster doesn’t measure, so the cost stays invisible. Atlassian’s 2025 survey adds the organisational side: 68% of developers said AI saves them more than 10 hours a week, and 50% said they lose more than 10 hours a week to friction elsewhere. Saved hours don’t help much if they pile up in front of a meeting or an approval queue.
Where the token spend comes from
When the token bill does get large, the reason is rarely that the model wrote a lot of code. It is that the agent kept re-reading context. Every tool call sends the conversation again, and a run that goes on for hours re-reads the same files hundreds of times. Anthropic’s cost docs say as much: usage climbs in a long session because the full conversation goes with every request, and agent teams use about seven times more tokens than a normal session when teammates run in plan mode.
My public benchmark shows how much this depends on the shape of the run. One task, rebuilding a mobile game from a gameplay video, given to three setups.
97% of those tokens were cache reads. The single agent didn’t do eleven times more work than the best setup. It went on eleven times longer, wandering, re-reading and fixing its own earlier choices: 3.7 hours against 1.5, with about 13 bugs I found by hand against no broken mechanics. The cheapest run was also the best one. That is the pattern I’d expect in general: a run that starts from a checked plan ends sooner, and a run that ends sooner costs less. One task, my own bug counts, caveats in the full write-up.
A model of the full bill for one feature
Here is a way to see the whole bill. Treat it as a model, not data. Assume a feature that an agent can build in a day, a loaded engineering cost of $75 an hour, and token spend in the range Anthropic reports, doubled for the setup with a second agent reviewing.
What one agent-built feature costs, by line
- Tokens
- Human review
- Fixing bugs that escaped
Data as a table
| Tokens | Human review | Fixing bugs that escaped | |
|---|---|---|---|
| Agent alone, person reviews | $15 | $150 | $300 |
| Agent plus agent reviewer | $30 | $38 | $75 |
Under those assumptions, doubling the token line cuts the total by more than two thirds. You can argue with every number in it, and you should plug in your own. The structure is hard to argue with: tokens are a two-digit line, people are a three-digit line, and the cheapest token is the one spent before code exists, on a plan someone checked.
How to cut the true cost of AI coding
- Measure cost per merged change, not per seat. Add tokens, review hours and the hours spent on bugs traced back to that change. Seat price alone tells you nothing.
- Move disagreement before code. A second model reviewing the plan is cheap. A second model reviewing a finished, wrong implementation is expensive, and a person doing it is more expensive still.
- Put hard stop rules on every run: a round limit, a no-progress limit and a ceiling. A run that can’t end is the main source of runaway token bills.
- Keep context small. Clear between unrelated tasks, keep instruction files short, and filter test and log output before the agent reads it. Claude Code hooks are a good place to do the filtering.
- Match the model to the job. Use the strongest model for planning and review, and cheaper ones for search and summarising.
- Let checks, not people, catch the routine problems. Every bug a build or a reviewer agent catches is one a person didn’t have to.
Bad and good ways to budget AI coding
| Approach | Why |
|---|---|
| Bad: cap tokens per developer | People route around caps by doing the expensive work by hand, which costs more |
| Bad: buy the cheapest seat and measure nothing | You can’t tell whether review and bug time went up or down |
| Bad: run parallel agents and pick the best diff | You pay several times and still don’t get a review |
| Good: budget per run with a ceiling and a parked state | Runaway runs end visibly instead of silently |
| Good: track review hours and escaped bugs next to spend | The lines that matter are on the same page |
| Good: spend more on review than on generation | Review tokens buy back hours, generation tokens mostly don’t |
I think the budgeting conversation will flip within a year or two. Today companies ask how to keep the AI bill down. The better question is how much more to spend on agents so that people review less, fix less and wait less. On every model I’ve built, that spend pays back. If you’d like help working out your own numbers, write to me.
Questions
How much does AI coding cost per developer?
Anthropic reports an average of about $13 per developer per active day for Claude Code in enterprise deployments, and $150 to $250 per month. The larger costs are usually review time and rework, which don’t show up on the AI invoice.
What are the hidden costs of AI coding?
The main ones are longer human review, larger pull requests, bugs that escape and need fixing later, and agent runs that go on too long. Faros AI found review time per pull request rose 91% on teams with high AI adoption.
Why is my AI coding agent using so many tokens?
Usually because the run is long, not because it writes a lot. Each request resends the conversation, so a session that wanders for hours re-reads the same files again and again, and parallel agents multiply that.
Is it cheaper to use two AI agents instead of one?
It can be. In my public benchmark, a setup where two models planned independently before coding used 34.3 M tokens against 389 M for one agent alone, because the run finished in 1.5 hours instead of 3.7.
