The Seat Was the Cheap Part: How to Budget AI Coding Spend Now That Every Developer Has a Meter

When Did a Coding Assistant Become a Variable Cost?

For three years, AI coding tools were budgeted like any other SaaS licence. You counted engineers, multiplied by a monthly seat price and moved on. A $19 or $39 seat was a rounding error next to a developer's salary, so few finance teams looked at it twice.

That model ended in 2026. According to CloudZero's breakdown of GitHub's billing change, GitHub retired premium requests and began usage-based billing on 1 June 2026, metering usage in AI Credits, where one credit equals one cent of model usage priced by input, output and cached tokens. Copilot Business and Enterprise seats kept their $19 and $39 prices and include pooled credits of the same value. A summer promotion gave Enterprise seats 7,000 credits. From 1 September the standard allotment of 3,900 applied, a 44% drop with no change to the seat price, which meant many organisations saw their first true usage invoice in October.

At Universe 2026, GitHub went a step further. As daily.dev's summary of the announcement puts it, GitHub Enterprise customers can now use all Copilot features, including the Copilot app, code review and automations, "without a separate subscription, paying for the AI credits they use." The seat is fading as the unit of purchase. The meter is taking its place.

Agentic tools never had a flat price to begin with. Claude Code, Cursor's agents and custom pipelines built on model APIs charge by token, and an agent that reads a large repository, runs tests and iterates on a failing build consumes far more than an autocomplete suggestion. The result is that the line item engineering leaders thought they understood now moves every month, and it moves with behaviour rather than headcount.

How Much Are Companies Actually Spending per Developer?

The honest answer is: far more variable than any seat price suggests. Anthropic's own documentation states that across enterprise deployments, Claude Code averages around $13 per developer per active day and $150 to $250 per developer per month, with 90% of users staying under $30 per active day. That is a useful anchor for a disciplined team using one agentic tool.

The upper end looks very different. Stackness compiled the public spend data available in October 2026, including The Pragmatic Engineer's interviews with 27 companies. Twelve of those companies spend $1,000 or more per developer per month, and four spend more than $3,000, while ten stay under $300. One quantitative trading firm went from $500,000 a month in January to $8 million in September. At the other end, a public company with 1,500 engineers caps spend at $150 per developer.

The same compilation cites Jellyfish data from May 2026 showing a mean of $248 per user, a 99th percentile of $2,452, and more than half of users under $100. The median company's typical user rose from $5 a month in August 2025 to $81 in May 2026. The spread inside a single company is often wider than the spread between companies: a few heavy users running long agent sessions account for most of the bill.

None of these figures is audited, and every one comes from vendors, volunteers or list-price estimates. But the shape is consistent. Average spend is moderate, the tail is very long, and the tail is growing fastest.

Will AI Coding Really Cost More Than a Developer?

In June 2026, Gartner predicted that AI coding costs will surpass the average developer's salary by 2028 as token consumption surges. The headline travelled fast, and it needs context. As CIO reported, Gartner senior principal analyst Nitish Tyagi explained that the prediction is based on a global average salary of $2,000 per month, and that "the goal is to alarm the industry about the impact of token cost if it is not governed and controlled."

So the forecast is not that a model will cost more than a senior engineer in Munich or Boston. It is that ungoverned token spend can grow to the same order of magnitude as a salary, and that it can grow faster than the productivity it buys. Tyagi put it plainly: "Without a governed engineering operating model, costs can escalate faster than the productivity gains" these tools deliver. He also noted that "tokenmaxxing is not directly related to higher productivity gains, but optimizing token consumption is."

For buyers of software development, this changes the arithmetic of team cost. When a token bill is a few percent of a loaded engineer cost, it does not matter much. When it reaches 20% or 50%, it matters a great deal who controls it, how it is reported and whether it is tied to output. We covered the cultural side of that problem in our piece on tokenmaxxing. This article is about the budget.

Why Do AI Coding Bills Spike Without Anyone Noticing?

Most cost surprises come from a small number of mechanisms, and almost none of them are visible to the developer while they work. The first is context. Agentic tools resend the conversation with every request. Anthropic's documentation explains that Claude Code sends your full conversation with every request, so a one-line question in a session that has been open all day still draws usage for the whole history. A session that is never cleared becomes steadily more expensive per action.

The second is cache behaviour. The Jellyfish analysis cited by Stackness found that cache reads made up 96% of tokens and generated code just 0.4%, with cache-related charges at about 83% of cost. In other words, most of the bill pays for the model re-reading context, not for writing code. A break longer than the cache lifetime forces the whole context to be reprocessed.

The third is model choice. Frontier models are often the default, and they are used for tasks a smaller model would handle. GitHub's billing documentation, quoted in the same compilation, warns that "there is no automatic fallback to lower-cost models." The fourth is parallelism. Anthropic notes that agent teams use approximately 7x more tokens than standard sessions when teammates run in plan mode, because each one keeps its own context window. Background loops, scheduled tasks and idle check-ins add more.

None of this is misuse. It is what happens when a tool designed to be generous with context meets an organisation with no budget model for it. That is why the fix is a set of engineering defaults and reporting, not a memo asking people to use AI less.

What Does a Workable AI Coding Budget Look Like?

Start with Gartner's own framework. Its recommendations, as summarised by CIO, sort work into three execution models: developer-led, developer-with-agent and fully agent-led, and define when agents should be used and how much autonomy they get. That classification is also the right basis for a budget, because each mode has a very different cost profile.

Developer-led work, where autocomplete and short chat do most of the AI lifting, is cheap and predictable. Seat-included credits usually cover it. Developer-with-agent work, where an engineer delegates bounded tasks and reviews the result, is the core of modern delivery and should carry a planned per-developer allowance, for example anchored on the $150 to $250 monthly range Anthropic reports. Fully agent-led work, such as large migrations, test generation across a codebase or overnight refactoring runs, should be budgeted as a project, with an estimate, an owner and a ceiling, the same way you would budget a load test or a data backfill.

Then set the controls at three levels. At the organisation level, set monthly ceilings and alerts in the vendor consoles. Anthropic, for example, documents spend limits at the organisation, group and member level for Team and Enterprise plans, and workspace limits in the API console. At the team level, publish a monthly report of spend against delivered work. At the task level, give agent-led projects an explicit budget before they start.

Avoid a single flat cap per person as the main control. A hard $150 limit is easy to explain, but it punishes the engineer doing the migration everyone else depends on and lets low-value usage continue unchecked under the cap. Budgets should follow work, not people.

Which Engineering Practices Actually Cut the Bill?

The most effective savings come from how work is set up, not from compression tricks. The replay study cited by Stackness found that three popular token-compression tools together saved just 3.7% of spend. Changes to context and model selection do far more.

Model routing comes first. Gartner recommends sending simple, high-frequency tasks to smaller models and reserving frontier models for complex, high-value work, and splitting work into smaller tasks so smaller models can handle them, according to CIO's report. In practice that means setting cheaper defaults for subagents, test runs and routine edits, and escalating deliberately.

Context engineering comes second. Tyagi's advice to developers was to "target context engineering as one of the most important skills for yourself." Concretely: clear sessions between unrelated tasks, keep repository instruction files short and move specialised guidance into on-demand skills, filter verbose test and log output before the model sees it, and disable tools and integrations nobody uses. Anthropic's cost guide lists each of these, and suggests keeping CLAUDE.md under 200 lines. We have written separately about using skill files to capture team knowledge, which pays off in both quality and cost.

Third, make the repository cheap to understand. A codebase with clear structure, fast tests and good documentation needs fewer exploratory reads. An agent working in a tangled monolith with a 40-minute test suite burns tokens rediscovering what a short architecture note could have told it. Repository hygiene used to be a quality argument. It is now a cost argument as well.

How Should You Measure Whether the Spend Is Worth It?

The metric that matters is cost per unit of shipped value, not tokens per developer. The Jellyfish quintile data reported by Stackness illustrates why. The top fifth of spenders used about $1,822 in tokens and merged 23 pull requests on average in Q1 2026, while the bottom fifth spent about $3 and merged 11. That is roughly twice the output for hundreds of times the cost, about $79 per merged pull request against less than $0.30.

That does not prove the heavy users are wasteful. Some of them are doing the hardest work. But it shows that spend and output are only loosely linked, and that the relationship needs to be measured rather than assumed. The same Stackness compilation cites a Harvard study of 718 firms that found lines of code rose 30% and pull requests 23% after coding-agent adoption, while resolved Jira issues and epics showed no significant change.

A sensible scorecard pairs AI spend with delivery outcomes: lead time for changes, change failure rate, rework, review time and completed roadmap items. Review a few high-spend workflows every month, as Gartner recommends, and ask whether the same result could be reached with a smaller model, a shorter context or a better-specified task. If the answer is yes, change the default, not the person.

What Should You Ask a Development Partner About AI Costs?

If you buy development capacity from an outsourcing or nearshore partner, AI spend is now part of what you are buying, whether the contract says so or not. Either the partner absorbs it in the rate, passes it through, or expects you to provide the tools. Each option is fine. Not knowing which one applies is not.

Ask four questions. Who pays for AI tooling and tokens, and is it capped? Which tools and models are used on your codebase, and under whose accounts and data terms? How is AI spend reported, and is it tied to delivered work? And who owns the context assets the team builds, such as repository instructions, skills and prompts, if you change vendors? We discussed the commercial side of this in our piece on renegotiating outsourcing contracts for AI productivity, and the continuity risk in our article on AI coding tool vendor risk.

At Stepto, our dedicated development teams in Serbia work with the client's own AI tooling and accounts where the client prefers, or with ours under agreed limits where they do not. Either way, spend is reported monthly alongside delivery metrics, agent-led work is estimated and approved like any other piece of work, and the repository instructions and skills our engineers write stay in the client's repository. The aim is simple: the client should be able to see what AI costs, what it produced and who decided it was worth it.

Nearshore teams also help with the part of the problem that is not about tokens. Cost discipline depends on senior engineers who can specify tasks well, review agent output quickly and keep the codebase easy for agents to work in. That is a staffing question, and it is where a well-run dedicated team in a compatible time zone pays for itself.