How much do developers spend on AI coding tools per month? October 2026 numbers
Tools in this post
The bill for AI coding tools now ranges from a $150 monthly cap to more than $3,000 per developer per month. The Pragmatic Engineer interviewed engineers at 27 companies and published the results on 20 October 2026. Twelve of the 27 companies spend $1,000 or more per developer per month, and ten spend under $300. Higher spend bought more code and more pull requests. In the larger datasets below, it did not buy a matching rise in shipped work.
How much do developers spend on AI coding tools per month?
In October 2026, a developer's AI coding bill runs from an $8 plan to several thousand dollars of API usage per month: flat subscriptions set the low end, usage at API rates the high end. Gergely Orosz's 27 companies split like this:
| Spend per developer per month | Companies |
|---|---|
| $3,000 or more | 4 |
| $1,000 to $3,000 | 8 |
| $300 to $1,000 | 5 |
| Under $300 | 10 |
The figures are self-reported: some are averages, some caps and one a team lead's impression. At the top, a quantitative trading firm went from $500,000 a month in January to $8 million in September. It gives its average as $1,600 per developer, which matches the bill spread over all of its roughly 5,000 staff, not its roughly 2,000 developers, and its biggest spenders are traders. At the bottom, a public company with 1,500 engineers caps spend at $150. June and July were the peak, and bills on API plans "have roughly halved" since.
List prices set the floor. Monthly prices for one developer on 22 October 2026:
| Tool | Individual plans | Team or business seat |
|---|---|---|
| Claude Code (Claude plans) | Pro $20, Max $100 or $200 | $25 standard, $125 premium |
| Cursor | Plus $8, Premium $30, Super $100, Ultra $200 | From $30, third-party models billed at API price |
| GitHub Copilot | Pro $10, Pro+ $39, Max $100 | Business $19, Enterprise $39 |
| OpenAI Codex (ChatGPT plans) | Plus $20, Pro $100 to $500 | Business $25 |
Sources: Claude, Cursor, GitHub, OpenAI. Cursor moved to these tiers after SpaceX bought it, and several cost guides still list its old $20 Pro tier. Bills above these prices come from usage at API rates or credits bought on top of a seat.
Anthropic now puts Claude Code at $150 to $250 per developer a month
Anthropic's own figure for Claude Code is "around $13 per developer per active day and $150-250 per developer per month" across enterprise deployments, with 90% of users under $30 per active day (cost documentation, read 22 October 2026, no sample size or window given). The page said "$6 per developer per day" until at least April 2026. The unit changed from a day to an active day, so the new figure is not a measured doubling.
A $248 mean against a typical user under $100
Average figures hide how uneven AI coding spend is. Jellyfish, which sells engineering analytics, estimated cost from its customers' token counts at list prices. In May 2026, more than half of the users it tracked spent under $100 a month. The mean was $248 and the 99th percentile was $2,452 (State of AI, H1 2026).
At the median company, the typical user's spend rose from $5 a month in August 2025 to $81 in May 2026. Single teams look the same:
- A 15-person startup posted on Reddit on 16 October that it spends $30,000 a month on tokens. Its developers spend around $2,000 each, some $5,000, and "the devop guy spend just around 200".
- An engineer at a large tech company described two groups, "half in the low three figures while the other half are in the low four figures", and added: "I can't tell the difference in output between a $3000 dollar spend and a $300 dollar spend". Both posts are single, unverified accounts.
Higher spend bought more pull requests, not more shipped work
The developers who spend most on AI do merge more pull requests, but far fewer per dollar. In Jellyfish's first-quarter 2026 data on 12,000 developers, the top fifth by spend used $1,822 of tokens each in the quarter and merged 23 pull requests on average. The bottom fifth used about $3 and merged 11. Dividing those averages gives about $79 of tokens per merged pull request for the top group against under 30 cents for the bottom (Jellyfish).
More pull requests did not mean more finished work. Fiona Chen and James Stratton of Harvard studied 718 firms on Jellyfish data: after a firm adopted coding agents, lines of code rose 30% and pull requests 23%, resolved Jira issues and epics did not change significantly, and review time rose 49%. The study measures adoption, not spend. The Pragmatic Engineer's companies report the same pattern: "PR frequency: flat" but "PR size: 3x" at one, and "Velocity: unchanged" at another.
Cached context, not the code the model writes, is most of the token bill
Most of an agent's token bill goes to context the model reads again on every turn. Across Jellyfish's customers, cache reads were 96% of all tokens and the code the model wrote was 0.4%. By cost, cache reads plus the cache writes that feed them came to about 83% of the bill, and generated output to 16%. Those are Jellyfish estimates for March to May 2026, from its own dataset and Cursor's usage API.
A replay of one developer's 500 Claude Code sessions, $926.31 of spend, found a different split: cache writes were 42% and output 29%. The two used different tools, models, prices and users, so neither number generalizes.
On Claude Opus 5.5, a five-minute cache write costs $5 per million tokens and a cache read $0.20 (Anthropic pricing), so a cache miss costs 25 times a hit. The post on what breaks the prompt-cache prefix measures those misses. Subagents multiply the context: Anthropic measured its own multi-agent research system using about 15 times the tokens of a chat (Anthropic).
Token compressors advertise 60-90% savings and saved 3.7% of one bill
Tools that cut the bill without changing the model save less than their headline numbers. RTK's repository says it reduces token consumption "by 60-90% on common dev commands", and its README adds that this is "not the same as cutting your bill by the same amount". In the 500-session replay, three tools together saved 3.7% of spend:
The compressors mostly remove cache-read tokens, the cheapest line on the bill (compression tools compared). The other moves have weaker evidence:
| Move | Saving | Who measured it |
|---|---|---|
| Harness trimming (Cursor) | 7% of users' token costs | Cursor, A/B tests on its own traffic, 23 September 2026 (Cursor) |
| Model routing (Not Diamond) | 39% to 66% of inference cost | The vendor, running public benchmarks itself, without task counts (Not Diamond) |
| Metering proxy (LiteLLM) | No savings figure: it meters and caps | Budgets enforce only with a database, per its docs |
Routing between plans has its own September numbers. On Stackness, as of 22 October 2026, 8 real profiles list Claude Code and 7 list Cursor, and none lists LiteLLM, RTK or Headroom (data sources): too few to say which tools sit under the cheaper bills.
What should a team measure before it sets a cap?
A spending cap works only when the team knows how spend is spread across users, what each dollar produced and what happens when a developer hits the limit. Caps are already common: the Pragmatic Engineer's interviewees quote caps from $150 to $4,000 per developer, and $25,000 per employee at the trading firm, and say "the caps are easily avoided". Measure four things first:
- Spend per user, per model and per session, not the team total. Claude Code reports per-user and per-model spend with a CSV export, and per-user cost in its Analytics API (Claude Code costs). A LiteLLM proxy in front of the agents does the same across vendors.
- The distribution. If the mean is 3.5 times the median, as in Jellyfish's May data, a cap set at the mean binds only the heaviest users.
- Output per dollar. Track cost per merged pull request, review time and change requests, the measures that moved in the Harvard study, alongside pull request count.
- What the cap does when it binds. On GitHub Copilot, an exhausted user budget stops that user, and "There is no automatic fallback to lower-cost models", per GitHub's billing docs.
Before raising a limit, one company in the sample has the developer run "an AI skill that looks for common reasons why you might be burning tokens", such as too many loops or subagents (runaway subagent costs).
How these numbers compare with larger sources
The larger sources measure who spends and set limits, not dollars per developer. Stack Overflow's 2026 Developer Survey, with more than 30,000 respondents, found that 38% of respondents said their organization sets limits on usage and 28% that it reviews spending data. It gave no dollar figures. DX estimates seat plus tokens at $200 to $600 a month per engineer, without a stated method (DX).
The Pragmatic Engineer's 27 companies sit higher, with 12 above DX's range, but Orosz interviewed people who agreed to talk, not a random sample. Which tools those bills pay for is in the AI coding tools developers list on Stackness.
Method: who measured what, and what the numbers do not show
Every dollar figure here is self-reported or estimated by a vendor; none comes from invoices a third party checked.
- The Pragmatic Engineer: 27 interviews, mostly anonymous, partly paywalled. Its overview puts the middle band at $300 to $500 and its chart at $300 to $1,000; the counts above follow the chart.
- Jellyfish: sells engineering analytics, prices tokens at list rates (no discounts or subscriptions) and supplied the Harvard paper's data.
- The replay and Reddit: one developer's sessions, two of three savings figures estimated; Reddit posts are single, unverified accounts.
- Stackness: public profiles only, bot accounts removed.
Key numbers
- 12 of 27 companies spend $1,000 or more per developer per month on AI, and 10 spend under $300, published 20 October 2026 (The Pragmatic Engineer).
- $150 to $250 per developer per month, or about $13 per active day: Anthropic's average for Claude Code in enterprise deployments, read 22 October 2026 (Anthropic).
- $248 mean and $2,452 99th-percentile monthly spend per user, against more than half of users under $100, May 2026 (Jellyfish).
- $1,822 against about $3 of tokens per quarter for 23 against 11 merged pull requests, top fifth against bottom fifth of spenders, Q1 2026 (Jellyfish).
- +23% pull requests, no significant change in resolved issues and +49% review time after firms adopted coding agents, 718 firms, paper dated 4 August 2026 (Chen and Stratton).
- 3.7% of spend saved by three token compressors together in a 500-session replay, 18 June 2026 (codepointer).
New posts by email
About one email a week with what we published. No account needed.
One email to confirm first. Every email has a one-click unsubscribe.
Which of these do you use?
Nobody on Stackness runs Jellyfish yet. Tick what you use and be the first.
