AI Coding Assistant Cost Per Developer: What to Budget in 2026

Your CFO wants one number. Your engineering leads want no ceiling. The gap between those two positions is where most 2026 AI budgets are quietly dying. The honest answer on AI coding assistant cost per developer is a range, roughly $150 to $250 a month once a team is past the pilot, with a long tail that can run four times that for a handful of heavy agent users. We have sat in enough budget reviews this year to know that the range itself is not the problem. The problem is that almost nobody can tell you which developers are in the tail, or why.

For the practice mechanics around cost ownership, see our guide on building a FinOps practice. This post is the AI-specific layer that sits on top of it: what the tools actually cost per head, why the bill behaves nothing like a SaaS line item, and which caps are real.

What a developer actually costs today

Anthropic publishes the figure most vendors will not. Across enterprise deployments of Claude Code, the average cost is around $13 per developer per active day and $150-250 per developer per month, with costs staying below $30 per active day for 90% of users. Read that last clause carefully. One developer in ten sits above $30 a day, and nothing in the average tells you who.

That distribution is why Uber's number made the rounds. The company burned through its entire 2026 AI coding budget in four months, then capped every employee at $1,500 a month per AI coding tool, with a process for requesting more. Uber President and COO Andrew Macdonald was blunt about the justification problem: "If you're not actually able to draw a direct line to how [many] useful features and functionality you're shipping to your users, that trade becomes harder to justify."

A $1,500 ceiling against a $200 average sounds absurd until you have watched a single engineer run three parallel agent sessions against a monorepo for a week.

The discipline caught up fast. The State of FinOps 2026 report puts 98% of FinOps practices on AI spend, up from 63% in 2025 and 31% in 2024, and names AI cost management the number one skill teams need to develop. Two years ago this was a rounding error. It is now the fastest-moving line in most engineering budgets.

Why falling token prices did not lower your bill

Unit prices are going down. Anthropic made Claude Sonnet 5's introductory $2 and $10 per million input and output tokens the standard price, cancelling the rise to $3 and $15 that had been scheduled for 1 September 2026. That is a real price cut on the most-used coding model.

Your bill still went up, because agentic coding changed the denominator. A chat completion is one request. An agent session is forty, and every one of them carries the whole conversation forward. The Claude Code docs put it plainly: Claude Code sends your full conversation with every request, and each tool use sends another request carrying that batch of results.

So the meter is not tracking how much code the assistant wrote. It is tracking how much context it re-read to write it. Cheaper tokens multiplied by many more tokens is a larger number.

Where the money goes inside one session

Here is a realistic day for one developer on Claude Opus 5, priced at $5 per million input tokens, $25 per million output, and $0.50 per million cache reads, with one-hour cache writes at $10 per million.

Assume 40 requests, a 120,000-token working context carried on each one, six cache writes as the context changes, and 1,500 output tokens per request.

| Line item | Calculation | Cost | |---|---|---| | Cache reads | 40 × 120,000 × $0.50 / 1,000,000 | $2.40 | | Cache writes (1h) | 6 × 120,000 × $10 / 1,000,000 | $7.20 | | Output tokens | 40 × 1,500 × $25 / 1,000,000 | $1.50 | | Total | | $11.10 |

The code the assistant wrote is $1.50 of an $11.10 day. Under 14%. Everything else is the cost of carrying context.

Run your own numbers rather than trusting ours. This takes the published per-million rates and the four inputs above:

"""Illustrative day-cost model. Rates are per million tokens, taken from
the vendor pricing page; swap in your contracted rates if you have them."""

def day_cost(requests, context_tokens, writes, output_tokens,
             cache_read, cache_write, output_rate):
    reads = requests * context_tokens * cache_read / 1_000_000
    written = writes * context_tokens * cache_write / 1_000_000
    out = requests * output_tokens * output_rate / 1_000_000
    return reads, written, out, reads + written + out

opus = day_cost(40, 120_000, 6, 1_500, 0.50, 10.00, 25.00)
sonnet = day_cost(40, 120_000, 6, 1_500, 0.20, 4.00, 10.00)
print(f"opus   {opus[3]:.2f}")    # 11.10
print(f"sonnet {sonnet[3]:.2f}")  # 4.44

Change writes to 20 and cache_write to 6.25 to see what a five-minute cache lifetime does to the same day.

Two consequences follow, and both are levers rather than observations.

The first is model choice. Run the identical session on Claude Sonnet 5 at $2 per million input, $0.20 per million cache reads, $4 per million one-hour cache writes and $10 per million output, and the same 40 requests cost $0.96 plus $2.88 plus $0.60, or $4.44. That is 60% off for a workload where Opus-grade reasoning is rarely the binding constraint. Default to Sonnet and escalate deliberately. Do not let Opus sit as the org-wide default because someone set it during the pilot.

The second is cache lifetime, and it is the one nobody budgets for. The prompt cache lives for an hour on a subscription and drops to five minutes once a developer is drawing on usage credits, and five minutes is also the API default. Hold reads and output flat in the table above and move those six one-hour writes to twenty five-minute writes at $6.25 per million, and the write line goes from $7.20 to $15.00. The day becomes $18.90 instead of $11.10, a 70% increase, for the same work by the same person.

Agent teams compound this. Anthropic measures them at roughly 7x the tokens of a standard session when teammates run in plan mode, because each teammate keeps its own context window open. Idle costs are trivial by comparison, under $0.04 per session for background work.

Seat, seat plus usage, or raw API

The three assistants most of our clients are choosing between price their variance very differently. That matters more than the headline rate.

| Tool | Entry tier | Team tier | What happens past the allowance | |---|---|---|---| | Claude | Pro at $17/month billed annually, $20 monthly | Team standard seat at $20/seat/month billed annually, $25 monthly, for teams of 2 to 150; Premium seat at $100/seat/month annually | Enterprise is $20/seat plus usage at API rates; on Team and Enterprise the seat allowance is the ceiling until an admin turns on usage credits | | GitHub Copilot | Pro at $10/user/month, including $15/month in premium request credits | Pro+ at $39/user/month with $70/month in credits; Max at $100/user/month with $200/month in credits | Premium requests beyond the included credit are billed on top | | Cursor | Individual at $20/month | Teams at $40/user/month | On-demand usage continues past the included amount, billed in arrears; Enterprise is quote-only |

Sources: Claude pricing and the Team plan help article, GitHub Copilot plans, Cursor pricing.

Our advice to clients with fewer than 150 engineers is to stay on a seat-allowance plan for as long as the allowance holds, and treat a developer hitting the ceiling as a signal worth investigating rather than a problem to buy your way out of. Seat plans make the bill boring, and a boring AI bill is worth real money in planning terms.

The moment you move to Enterprise seats plus API-rate usage, or to raw API and cloud-provider billing on Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry, the variance lands on you. That is a defensible trade at scale. It is a bad trade before you have per-user telemetry, because you will be reconciling a five-figure invoice with no idea which team generated it.

The caps that actually exist, and the order they fire in

Most teams assume they have less control than they do. On Claude for Teams and Enterprise the hierarchy is documented and specific.

The seat allowance is the default ceiling, and it resets on a rolling five-hour window and a weekly window. Nothing is billed past it unless an admin turns on usage credits. Once credits are on, spend limits apply at the organization, group, and individual member level, and the Enterprise consumption guide is explicit about precedence: "Individual limits always override group limits, regardless of which is higher," while "Org-wide limits remain the hard ceiling." Group limits live under Organization settings, then Usage, then By group, set to a dollar amount or Unlimited.

Set all three. The org limit is your blast radius. The group limit is your per-team budget. The individual limit is the one you use for the two engineers running agent fleets.

On the Claude Console the equivalent is a workspace spend limit, and Claude Code gets its own workspace automatically on first authentication. On Bedrock, Google Cloud or Foundry there is no Anthropic-side cap at all, so the control is your cloud budget tooling, a self-hosted Claude apps gateway with per-user spend limits, or an LLM gateway such as LiteLLM that tracks spend by key.

One setting is worth knowing about because it prevents an argument rather than an overspend. By default every cost figure a developer sees, in /usage and in the status line, is computed at list price. If you have negotiated rates, those numbers do not match your invoice and someone will eventually escalate the discrepancy. The modelPricing managed setting takes your contracted rates and makes the reported figures match, and it has to be delivered through managed settings because Claude Code ignores the key in user, project and local settings.

Instrument before you cap

A cap set without telemetry is a guess that interrupts people. Get per-user numbers first, then set the number.

• On Enterprise, the Enterprise Analytics API returns per-user usage and cost across Claude surfaces. A Primary Owner creates a key with the read:analytics scope at claude.ai/analytics/api-keys.
• On Teams, export the spend report CSV, which lists token usage and estimated spend per user and per model, updated daily.
• On any setup, including cloud providers, OpenTelemetry export streams per-user token and cost metrics into your own observability stack in near real time. This is the only option that works everywhere, and it is what we put in place when a client is on more than one billing path.

If you are running Claude Code through the Console rather than seats, size your rate limits before the first invoice teaches you to. Anthropic's per-user recommendations drop as the organization grows, because concurrency falls:

| Team size | TPM per user | RPM per user | |---|---|---| | 1-5 users | 200k-300k | 5-7 | | 20-50 users | 50k-75k | 1.25-1.75 | | 100-500 users | 15k-20k | 0.37-0.47 | | 500+ users | 10k-15k | 0.25-0.35 |

At 200 users you would request roughly 20k TPM each, or 4 million TPM in total.

What we tell clients to budget

Start at $200 per active developer per month and hold it for one quarter. That sits inside the published $150-250 band, it survives contact with a real team, and it gives you a number to defend before you have your own data.

Then adjust on evidence rather than anecdote:

• Count active developers, not seats. A 60-person engineering org with 35 people actually using an assistant is a $7,000 month, not a $12,000 one.
• Set the org cap at roughly 1.5x your planned spend. Enough headroom for a heavy sprint, tight enough that a runaway loop stops before it becomes a board slide.
• Cap individuals at 3x the average and review every breach. Most will be legitimate. The ones that are not are usually a stale session that nobody cleared, or Opus left as a default.
• Budget separately for automation. Scheduled tasks and CI agents fire on their own schedule and belong in a platform line item, not in a per-developer average.

The ROI case is a separate exercise, and it is the one Macdonald was pointing at. Our post on measuring DevOps ROI for the C-suite covers how to tie this to delivery metrics your board already reads, and how AI coding assistants change DevOps workflows covers what the tools are actually good at. Spend without an attribution story is how you end up cancelling licences in month five.

When to Get Help

Most teams get the caps wrong in one of two directions. Too loose and the quarter is gone by April. Too tight and your best engineers spend their afternoons waiting for a window to reset, which costs far more than the tokens would have.

We help engineering leaders set AI spend policy that holds: per-user telemetry across mixed billing paths, cap hierarchies that match how teams actually work, and a budget you can put in front of a CFO with the arithmetic attached. If your AI bill is growing faster than you can explain it, get in touch.