In April, Uber’s chief technology officer, Praveen Neppalli Naga, said the company had already spent its entire 2026 budget for Claude Code. It was the fourth month of the year. Use had gone from about a third of engineers in February to 84% in March. A typical engineer’s bill ran $150 to $250 a month, heavy users $500 to $2,000, and Naga had burned $1,200 of tokens himself in a single two-hour demo. In late May his chief operating officer, Andrew Macdonald, was asked whether more tokens were producing more useful features. His answer: “That link is not there yet.”
Look at the units in that story. The budget was planned per engineer. The bills were reported per engineer. The alarm was about engineers. Every published number is divided by a head.
I think the head is the wrong denominator, and Uber is only the most visible company using it.
The thesis
Your AI coding bill is a property of the codebase, not of the person holding the key. Almost all of it is the model reading your code, over and over, and how much reading it has to do is set by how the code is laid out. Budgeting tokens per engineer, ranking engineers by tokens, and setting token minimums per engineer all manage the wrong variable. Set the budget per repository, and spend the first money making the repository cheaper to read.
Most of the market disagrees. Gartner frames the problem per developer: its senior principal analyst Nitish Tyagi says 23% of technology leaders already spend $200 to $500 per developer per month on coding agent tokens, 6% of organisations spend more than $2,000, and Gartner expects AI coding costs to exceed the average developer’s salary by 2028. Vendor admin consoles open on a table of users. The per-head frame is the default, and it is the frame the bill arrives in. That does not make it the frame the cost is generated in.
What the bill is actually made of
The best public breakdown of a coding agent bill is Jellyfish’s State of AI in Software Engineering report for the first half of 2026. Jellyfish sells engineering metrics tooling, so treat it as vendor data, but the sample is large: 18 million Claude Code turns, 37 million pull requests, and separate studies across 17,331 users at 289 companies and 134,911 developers at 670 companies.
Here is the line that matters. Cache reads are 96% of all tokens. The code the model writes is 0.4%.
A cache read is the agent reloading context it has already seen before it makes the next edit. It is billed at roughly a tenth of the normal input rate, which is why nobody worries about it. It is cheap per token and enormous in volume. Cache reads and cache writes together come to about 83% of the bill. Generated output, the thing everybody thinks they are paying for, is 16%.
So when you pay for a coding agent, you are mostly paying it to read. It reads the files around the change, the files those files import, the configuration, the tests, the conventions file, and then on the next loop it reads them again. How much it has to read to make one correct change is not a property of the engineer who typed the request. It is a property of the code.
I have been writing software since 1995, and the first question I ask of any unfamiliar codebase has not changed in thirty years: how many files does a one-line change have to touch? If a business rule lives in one place, the answer is one file and its test. If the same rule lives in four services, two of which disagree, the answer is six files and an argument. A human pays for that in hours. An agent pays for it in context, on every loop, at a rate somebody else sets.
The rest of the Jellyfish data points the same way.
The spend is skewed, and the skew looks like a people problem. Median monthly spend per user went from about $5 in August 2025 to $81 in May 2026, a sixteenfold rise in ten months. The mean in May was $248. The 99th percentile was $2,452, or 35 times the median. In March 2026 the first individual user spent more on tokens in a month than a junior US developer earns, about $12,500. At the 90th percentile, weekly Claude Code tokens per user tripled from 50 million to 170 million while the median stayed flat. Show a finance team that distribution and they will ask who the heavy users are. That is the wrong next question.
The price moves without the price moving. Between Opus 4.6 and 4.7 the per-token price did not change, but the same workload cost about 40% more because the new tokenizer counts the same text as more tokens. Nobody on your team did anything differently. The bill moved anyway. A per-engineer budget will report that as forty per cent more spend per head, and somebody will go looking for the heads.
The returns depend on the repository. Jellyfish sorted codebases into four tiers from highly centralised to deeply fragmented. Centralised and balanced codebases returned about 4x pull request throughput for their AI adoption. The most fragmented returned 0.9x, which is below break-even: the more AI those teams used, the less they shipped relative to cost. Same tools, same prices, same kind of engineers. Different code.
The other big lever also belongs to the repository. Teams that invest in context files, meaning CLAUDE.md files, Cursor rules and project prompts, get more out of the same tokens. Each doubling of that investment bought roughly 29% more merged pull requests per developer per week. Those files are checked into the repository. They describe the repository. When an engineer leaves, they stay.
Past a point, more tokens buy almost nothing. The first 0.7 million or so tokens returned about 11 merged pull requests per million. Later increments returned well under one per million. Jellyfish puts the point of diminishing returns around 2 million tokens per user per month, and calculates that heavy spend only pays off when a merged change is worth more than about $69.
Put those together. The two levers that change what you get for a token, the shape of the code and the context written down about it, are both properties of the repository. The per-engineer number is downstream of both. Manage it directly and you are managing a symptom.
Case one: Uber budgeted by the head
Uber gave its engineers Claude Code in December 2025, and roughly 5,000 of them took it up faster than forecast. Its first quarter results said 95% of engineers used AI coding tools every month and agents wrote more than one in ten lines of code. The company spent $3.4 billion on research and development in 2025, up 9%, and its chief executive, Dara Khosrowshahi, said hiring would slow to make room for AI investment.
Now look at how the budget broke. A per-engineer budget is the product of two forecasts: how many engineers will use the tool, and how much each one will spend. Between February and March the first forecast moved from a third to 84%. Headcount did not change. The share of heads using the tool nearly tripled in a month, and each of those heads was running the most read-heavy software Uber had ever bought against whatever codebase they happened to work in.
None of the public reporting says which systems the money went into. Every published figure is per engineer: the typical bill, the heavy bill, the CTO’s demo. That is not a criticism of the reporting. It is what the budget was built to answer. If you plan per head, you can only ever learn things about heads.
Macdonald’s complaint was that more tokens had not yet produced more useful features. On the Jellyfish data, that is exactly what you would expect from a company spending at the same rate across codebases with different architectures. Some of that money was buying 4x. Some was buying 0.9x. Averaged per engineer, it looks like nothing.
Case two: Meta, Microsoft and Salesforce ranked the head
If budgeting per head hides the cause, ranking per head creates a new one.
In the spring, a Meta employee built an internal leaderboard nicknamed Claudeonomics. It ranked about 85,000 people by token use, listed the top 250, and handed out titles like “Token Legend”. Gergely Orosz of The Pragmatic Engineer reported that Meta staff used 60.2 trillion tokens in 30 days, about $900 million at Anthropic’s list prices and, on his estimate, still more than $100 million at the discounted rate Meta likely pays. Engineers described large amounts of wasted agent use. The leaderboard came down within about a week of The Information reporting it.
Microsoft has run an internal token dashboard since January 2026, and distinguished engineers sat in its top five. One engineer, worried about looking like a light user, admitted to inflating usage by asking the model about documentation that was easy to look up and prototyping features they never intended to build.
Salesforce went further and set minimums: $100 a month on Claude Code and $70 on Cursor, a $170 floor, or be flagged. A desktop widget refreshed each person’s spend every 15 minutes. The maximums, $250 and $170, could be overridden with a single button.
Duolingo’s chief executive, Luis von Ahn, reversed a policy that tied performance reviews to AI usage after staff said they were being judged on tool adoption rather than results.
I started writing code early enough to catch the tail of lines-of-code reporting and late enough to remember why it died. A token leaderboard is the same instrument with a bigger unit price. And notice what it rewards. The cheapest way to move your own number is to make the agent read more: open more files, rerun the loop, load the whole directory as context. That is the 96%. A per-person token ranking is an incentive to grow the exact line of the bill that buys the least.
There is a quieter cost too. The engineer who spends a week deleting duplicate code, consolidating a rule into one place and writing a proper context file has just made every future agent call against that repository cheaper. Their own token count for the week is close to zero. On a leaderboard, the person who lowered the company’s bill most ranks last.
Case three: Shopify’s per-person control found system faults
Shopify is the useful counterexample, because it started where Meta ended up and then learned.
Orosz believes Shopify built the first token leaderboard, in 2025. Its head of engineering, Farhan Thawar, said at the time that he wanted to celebrate heavy users and to understand spend like $1,000 a month on Cursor. Since then Shopify has renamed the leaderboard a usage dashboard to stop the competition, put token spend on internal profiles, and added circuit breakers that cut off access when one person’s spend spikes inside a day.
Here is the part worth reading twice. Those circuit breakers caught runaway agents and exposed infrastructure bugs. The control was attached to a person, but what it actually found were faults in systems: loops that would not terminate and tooling that was broken. The spike had a name on it. The cause lived in the code.
Shopify has also shifted what it looks at, from who spends the most to who generates the most expensive tokens. That is the right instinct. An expensive token is one spent loading context that a better structured repository would not need loaded. Follow that question far enough and you arrive at the repository.
Gartner supplied the cleanest illustration without meaning to. Tyagi described an Indian IT services firm where a single developer ran up about $20,000 in token costs, and leadership judged it worth it because the work was a legacy modernisation. On a per-engineer dashboard, that person is the most expensive employee in the building and the first conversation on Monday. On a per-repository ledger, it is a line item on a migration with a scope, a budget and an end date. Same $20,000. One view creates a performance problem. The other describes a project.
Where this breaks
People do differ. Jellyfish found that among the longest sessions, lightly supervised runs produced about 11 times the net lines of code of heavily supervised runs of the same length. How long someone lets an agent run, and how well they frame the task, changes the bill. I accept that. The person sets the number of loops. The repository sets the cost of each loop. Net lines are also not value, and Jellyfish’s own returns curve flattens hard past the first couple of million tokens.
The bill arrives per seat. Vendors invoice by user and finance allocates by cost centre. Rebuilding that per repository is extra work, and in some organisations the tooling will not support it cleanly. True. But most providers already let you separate spend by project, workspace or key, and a 30 day experiment with one key per repository costs an afternoon to set up.
One repository makes the point moot. A five person startup with a single codebase gets nothing from this distinction. The argument starts to pay once you have several codebases of different ages and shapes, which describes most companies past Series B, almost every private equity roll-up, and every services firm working in client code.
It is vendor data. Jellyfish sells the measurement, publishes few confidence intervals, and notes wide ones at the top tier. Treat the 4x and 0.9x as direction, not precision. The 96% cache share is the least contestable number in the report, because it falls out of how these agents work.
What I would do on Monday
Split last month’s bill by repository, not by person. If your tooling cannot do it, issue one key or project per repository for the next 30 days. You will learn more from that month than from a year of per-seat reporting.
Rank repositories by cost per merged change. Put the list next to each repository’s age and the number of places its core rules live. I would be surprised if the top of the cost list and the top of the duplication list were different codebases.
Give the worst repository one week of reading cost reduction. Delete dead code, consolidate the rule that lives in four places, write the context file. Then measure the same work again. That week is the cheapest token optimisation available to you, and no vendor will sell it to you.
Replace minimums and leaderboards with repository ceilings and a daily circuit breaker. Route the alert to whoever owns the repository, not whoever owned the key. Shopify’s breakers found bugs. Yours will too.
If you sell services, price tokens per client codebase. Your messiest client repository is now your least profitable account per change, and your rate card does not know it yet.
Back to April. Four months, one budget, and every number that came out of it divided by a head: the typical bill, the heavy bill, the two-hour demo. The question I would have asked first is the one nobody published. Which repository read the money?
The engineer holds the key. The codebase writes the bill.
If you are setting next year’s coding agent budget and would rather argue about repositories than headcount, book half an hour with me.