AI coding tool spend per developer is the all-in monthly cost of AI coding tools for one developer: the seat fee plus metered usage. Anthropic's Claude Code cost guidance reports an average of around $13 per developer per active day and $150-250 per developer per month across enterprise deployments. Anthropic adds that costs stay below $30 per active day for 90% of users.
Metered usage grows with use. Tools count tokens, the small chunks of text a model reads and writes. They convert tokens into credits or bill them at API rates, the per-token prices each provider publishes.
An active day is a day the developer actually uses the tool. Token cost is only the metered usage. AI cost also includes the seat and the hours people spend reviewing AI-written code.
Why does the number matter? Someone asks for it because a decision is coming: renew, expand, standardize on one tool, or cap spend. A useful number answers two questions: how the AI is used, and what it returned.
The honest answer is a range. Three published sources measure spend in different ways, and each shows a different part of the bill.
Jellyfish's H1 2026 research review found that in May 2026, more than half of users still spent under $100 a month. Yet the mean ($248) ran 3.5x the median, and the 99th percentile ($2,452) ran 35x it.
The median is the developer in the middle. The mean is the plain average, and a few heavy users can pull it far upward. Jellyfish's figures come from its own customer data.
The Harvard working paper on coding agents finds the median worker spends $178 a month, the mean $808, and 20% of workers spend over $1,000. Authors Fiona Chen and James Stratton drew those figures from Cursor and Claude Code billing data for a subset of firms.
The paper is not peer reviewed, and the version cited here is dated November 14, 2026. The table compares the three sources by what each measures, its typical and tail figures, and its scope.
| Source | What it measures | Typical figure | Tail figure | Scope caveat |
|---|---|---|---|---|
| Anthropic Claude Code cost docs | Claude Code cost per developer | Average $150-250 per month | Under $30 per active day for 90% of users | Average, not median; enterprise Claude Code only |
| Jellyfish H1 2026 review | Spend per user, May 2026 | Over half under $100; mean $248 | 99th percentile at $2,452 | Jellyfish customer data only |
| Harvard working paper | Spend per worker | Median $178; mean $808 | 20% over $1,000 | Billing data for a subset of firms; not peer reviewed |
In both sources that report a median, the mean sits far above it. A budget built on the average will overshoot for most developers and fall short for a few.
A seat used to be the whole price. Now a seat buys a usage allowance, and anything past that allowance is metered.
GitHub's usage-based billing announcement, dated April 27, 2026, lists Copilot Business at $19/user/month, including $19 in monthly AI Credits. AI Credits are GitHub's unit for metered use. The new billing started June 1, 2026, and prices input, output, and cached tokens at each model's listed API rates.
The seat price now equals the allowance, and every request past it adds to the bill. This breakdown of hidden GitHub Copilot costs shows where the extra charges come from.
Claude Code and Cursor also combine plan allowances with usage billed at model rates. The Claude Code pricing guide explains what happens when usage overflows a Claude plan.
For Cursor, read how Cursor pricing works, including how third-party model usage adds to the seat. Pricing details in this guide are as of November 2026.
Finout, an enterprise-grade FinOps platform for cloud and AI spend, sorts AI spend into four layers by visibility. In Finout's four layers of AI spend, token-based developer tools such as Cursor, Claude Code, and GitHub Copilot sit in Layer 3, a blind spot. Their costs add up across seats and projects, apart from the cloud bill FinOps teams already watch.
Four costs can land on top of the seat:
Two developers on the same seat can produce very different bills. The drivers are habits and workloads.
Anthropic's cost documentation says per-developer costs vary widely based on model selection, codebase size, and usage patterns such as running multiple instances or automation. Parallel sessions multiply usage, and more capable models usually carry higher per-token rates.
The agent spends most of its tokens reading code. A cache read is the tool reloading your repository into the model's context before each edit. The same Jellyfish review found cache reads are 96% of all tokens, while the code the model actually writes is 0.4%.
A large repository and a long session cost more, even when the output is small. These token habits for coding assistants show how shorter, scoped sessions help.
That 35x gap between the median and the 99th percentile comes from a small group of power users. These developers run agents for long stretches or across several sessions at once.
Splitting the invoice by headcount hides them. Finout's guide to allocating coding-assistant spend by identity warns that headcount-based chargeback distorts the cost signal. Chargeback means billing each team for what it uses.
The same guide notes a greenfield developer may consume five to ten times the tokens of a developer focused on code review or configuration changes. Greenfield work means building new code from scratch. Allocate by identity instead: tie each dollar to a login, API key, or seat.
Each step depends on the one before it. You can't report by team until identities map to teams, and you can't judge payback until you can report.
Step 1 matters because each tool reports usage in its own format. For Claude, this guide to per-user Claude cost attribution covers per-user cost, commits, and pull request data.
For Cursor, Cursor cost management in Finout maps each Cursor user to a team and product. Those mappings follow your Virtual Tag taxonomy, the same rules you apply to cloud spend.
Step 2 is where measurement usually breaks. Without an identity map, you can only divide the bill by headcount, and power users disappear into the average.
A merged pull request (PR) is a code change that passed review and joined the main codebase.
Output rises with spend, but not in proportion. The Jellyfish AI Engineering Trends report found that a tenfold token increase, from the median developer-week's level, buys about 2.2x the merged PRs. Jellyfish calls the link correlational: the two move together without proof that one causes the other.
This is the value question: what did the AI return for what it cost? Cost per merged PR answers it better than seat price because it measures delivered work. Jellyfish calculates it as salary plus priced AI usage, divided by merged PRs.
In the same report, the median company's cost per merged PR fell by about a third, from $1,202 to $820, over the past year. Meanwhile, the median company ended the third quarter at 98% of its first-quarter headcount while spending 3.8x as much per engineer.
The Harvard paper adds a caution. Twelve months after firms adopted AI agents, pull requests opened rose 35.7%, while resolved issues rose 13.7%, a result the authors call borderline significant. An issue is a tracked unit of work, such as a feature or bug ticket.
Review became the bottleneck. After adoption, the average time from the code's review submission to its approval increased by 56.1%. That waiting time is a people cost, and it sits outside the token line.
One caveat applies to both sources. Jellyfish sells engineering analytics tools and supplied the data for the Harvard paper, which means the two are not independent confirmation.
Budget from the distribution you measured. Cover the median developer with base seats, the 90th percentile with a pooled allowance, and the top tail with a named review.
A pooled allowance is a shared bucket of usage the whole organization draws from. A named review means you look at each top spender with their manager and agree on the right tier.
For finance, the shift from seats to consumption changes predictability. A seat bill is flat, while a usage bill moves with how engineers work each week.
Vendors now ship controls that match this structure. Under GitHub's billing controls, admins can set budgets at the enterprise, cost center, and user levels. When the included pool runs out, organizations choose to allow additional usage or cap spend.
With Claude Code cost controls, admins can set spend limits at the organization, group, or individual member level. The table maps each budget component to what it covers and the control that fits it.
| Budget component | What it covers | Control to use |
|---|---|---|
| Base seats | The median developer's seat fee and allowance | Standard seats on each tool |
| Pooled allowance | Usage up to the 90th percentile | Pooled credits with cost center budgets |
| Named review | Power users above the 90th percentile | User-level budgets or member spend limits |
| Review capacity | Reviewer hours created by AI-written code | Review time tracked beside spend |
Forecast in ranges, and revisit the forecast monthly while adoption moves fast. Jellyfish's H1 2026 review found the median user at a typical company went from about $5 a month to $81 in ten months.
Your next move depends on what your distribution shows.
Each team owns a different piece of AI coding tool spend per developer. Engineering owns session habits, FinOps owns allocation by identity, and finance owns the forecast range.
Finout is an enterprise-grade FinOps platform for cloud and AI spend, built for the agentic era. Finout treats AI coding spend like any other technology spend, with the same allocation, planning, and governance.
FinOps for AI brings in Anthropic, OpenAI, and Cursor costs like any other cloud spend. Finout's AI cost management is included at no extra charge. Finout's integrations also cover OpenAI Codex and GitHub.
Billy answers cost questions in plain language, such as which team's Claude Code spend rose last month. Billy runs read-only and respects your access permissions.
FinOps Agents is Finout's agentic layer for detection and investigation. Detection Agent can flag a developer whose spend jumps, using rules you define, such as cost per commit. Investigation Agent then traces the finding to its owner, its history, and the change that caused it.
MCP brings governed Finout cost data into MCP-compatible tools such as Claude and Cursor. An engineer can ask whether a pull request changed spend without leaving the code editor.
Finout also handles the core FinOps work:
Want to see spend per developer by team and tool? Book a demo.