The Quiet Repricing of AI Coding Tools
Copilot, Cursor, Codex, and Claude Code all moved to usage-based billing inside twelve months. The driver is the same.
The Quiet Repricing of AI Coding Tools
Copilot, Cursor, Codex, and Claude Code all moved to usage-based billing inside twelve months. The driver is the same.
Pensacola, You would drive from Atlanta with a cooler for this fish market!
Claude feels like a Starbucks card now. I keep adding $20 here, $50 there, and the balance burns down in days. The denominations are small enough that I do not think about them at the moment of purchase. The aggregate shows up on the credit card statement.
Every major AI coding tool ships some version of this, and the vendors built the mechanism on purpose. GitHub’s new pricing literally calls the unit “AI Credits” and prices them at one cent each. Anthropic’s “extra usage” toggle on Pro and Max plans keeps Claude responding past the rate limit, with overage billed at API rates. Cursor handles overage the same way once you burn through the monthly pool. Codex sells additional credits to Plus users who run out, without requiring an upgrade. The vendors calibrate each mechanism to bypass the bigger spending decision.
The reload economics work for the same reasons Starbucks reloads work. Credits feel pre-paid even though you are still spending real money. Most engineers run two or three of these subscriptions at the same time and lose track of which is which. From inside a coding flow you cannot predict what the next prompt is going to cost, so you reload rather than question the spend. GitHub stated the breakage angle in the announcement itself: AI Credits do not roll over month to month. The unused capacity at the end of every cycle goes to the vendor as margin.
GitHub’s April 27 announcement extended the pattern. Every Copilot plan moves to usage-based billing starting June 1, 2026. Premium request units retire. Tokens take their place at published API rates for whichever model handled the request. I read the announcement twice, first as a Copilot user, then as someone who has been watching the same shift across every major AI coding tool.
Cursor moved from request-based to credit-based in June 2025, the change so abrupt that the company issued a public apology on July 4 and refunded surprise charges between June 16 and that date. OpenAI moved Codex from per-message to token-based pricing on April 2, 2026 for Plus, Pro, and Business plans, then extended the change to Enterprise on April 23. Copilot’s June 1 shift closes the twelve-month window.
Claude Code is the holdout, sort of. Anthropic still sells flat subscriptions, but usage limits tighten under load, weekly caps kick in, and overflow rolls to API rates. The wrapper hides token economics. It does not change them.
What broke
Request-based pricing assumed a request was a meaningful unit of work. For a long time it was. An autocomplete suggestion, a chat turn, a single-file edit, all roughly comparable. GitHub charged one premium request unit and applied a model multiplier. Cursor charged one fast request. Codex charged per message.
Agents broke the unit. A four-second autocomplete and a forty-five-minute agentic refactor are not the same request. One reads a partial line. The other reads a hundred files, writes twenty, runs tests, iterates on failures, and pulls Opus back into the loop three more times before it stops. The token gap between the two is roughly three orders of magnitude, and until very recently the price gap was zero.
GitHub said it plainly in the announcement: “a handful of requests can incur costs that exceed the plan price.” Premium subscriptions priced for IDE-era completion behavior cannot absorb agent-era token volumes. Investor patience covered the gap for a while. The math caught up.
The four tools, repriced
GitHub Copilot. Pro $10, Pro+ $39, Business $19/seat, Enterprise $39/seat. Dollar prices unchanged on the page. Each dollar now buys AI Credits that convert to tokens at posted API rates. Completions stay free; agentic work meters.
Cursor. Pro $20, Pro+ $60, Ultra $200, each with a credit pool sized to the plan price. Auto mode is unlimited; manual model selection draws from the pool at API rates. Cursor took the worst of the rollout damage on this shift.
OpenAI Codex. Plus $20, Pro $100 or $200. The $100 tier launched in April to match Anthropic’s Max 5x at the same price. Codex meters in credits per million tokens, with a May-31 promo doubling Pro $100 throughput.
Claude Code. Pro $20, Max 5x $100, Max 20x $200, flat subscriptions on the surface. Weekly caps and a five-hour rolling window tighten under load. The v2.1.89 release in March inflated token consumption 3x to 50x. A flat subscription does not insulate you from versioning surprises.
The driver: agents and parallelization
Three subagents running in parallel do not cost three times what one agent costs. The spend goes superlinear, because each agent runs a tool loop, each loop reads context, each read inflates the next turn’s input tokens, and cache pricing changes the slope but not the direction. The vendors built capacity assuming developers operated tools sequentially. Engineers now operate them concurrently, often in the background, sometimes overnight.
Subscriptions priced for sequential work cannot absorb concurrent work, which is what the entire category just repriced around.
The wrapper versus the model
Token-based billing exposes a question that flat subscriptions hid: what is the IDE wrapper actually worth?
Cursor’s overage rate matches the underlying API rate for whichever model handled the request. Copilot’s AI Credits convert to tokens at published API rates. Codex bills credits against API token economics. In each case the subscription buys a credit pool, and once the pool empties the price per token matches what you would pay going direct to the model provider. The wrapper makes its money on the subscription fee, the seat license, and the operational margin it captures on caching and infrastructure underneath.
The wrapper fee does not buy the model. Models are fungible across providers. The fee buys the editor integration, the agent runtime, the tool loop, the MCP server plumbing, the repository indexing, and the team dashboard.
For a solo developer the question gets sharp. Claude Code already runs against the Anthropic API directly if you set ANTHROPIC_API_KEY in your environment. Cursor allows BYOK for OpenAI, Anthropic, and others. The wrapper-vs-direct decision now turns on how much you value the agent harness over raw API access, not on whether the underlying model is cheaper through one path or another.
One specific case still favors the subscription wrapper by a real margin: cache-heavy long sessions on Claude Code Max. Over 90 percent of tokens in a long coding session are cache reads, and the flat Max plan absorbs those at no marginal cost. On the API, cache reads still cost roughly $0.50 per million tokens for Opus. One published case study tracked an eight-month heavy user whose API-equivalent spend would have been about $15,000 against $800 actually paid on Max subscriptions. That gap is the cache subsidy, and it is the strongest argument left for any flat subscription in this category.
What this means for developers
I hit cap limits all the time. The five-hour rolling window on Claude Max ends at the wrong moment regularly. By Thursday afternoon on a heavy week the weekly active-compute cap kicks in. Sometimes I pay the extra usage rate and keep working. Sometimes I close the tab and wait it out. Either choice breaks the flow of what I was doing.
Before each session I now decide which work actually needs a frontier model. The boilerplate edits, the test scaffolding, the refactors inside an existing pattern: this work does not need Opus, and Sonnet is overkill most of the time. What it needs is a model that can read the file, follow the convention, and produce code that compiles. A purpose-built coding model running on my own hardware does that work without consuming a credit pool or hitting a cap.
I save the frontier subscription for the hard problems: the system design questions, the multi-file refactors with weird coupling, the debugging where the trace is opaque, the spec-writing for anything new. Everything else offloads to a smaller purpose-built model running locally. The savings is real on the subscription page, but the bigger win is not having my work blocked at 2pm on a Thursday because a vendor decided I had used my allotment.
This is also when the local model question stops being theoretical for me. The cap-hits are predictable. Most of my work does not need frontier quality. A Mac Studio under the desk is starting to look like the answer. The flow problem is what pulls me there.
Architect and developer
The split between routine and architect work maps cleanly to seniority on a team. The work I would assign to a mid or senior developer goes to the local model: implementing a clear spec, boilerplate, test scaffolding, refactors inside an existing pattern. The work that needs a principal engineer or architect stays on the cloud subscription through a $20 Pro or Plus tier: system design, multi-file refactors with weird coupling, deciding what the test suite needs to cover, debugging when the trace is opaque.
That work is where the quality gap between Claude Sonnet 5 at 92.4 percent on SWE-Bench and a local Qwen3-Coder at 70.6 percent actually matters. For a solo developer, the cloud subscription buys principal-level capability for the cases that need it.
Mid and senior work does not need a frontier model. A purpose-built local coding model handles it at 60 to 120 tokens per second on competitive hardware, with no rate limits and no per-token cost. Most of my coding day is this kind of work.
The architect’s output extends past code suggestions. It includes the spec, the AGENTS.md, the coding style guide, and the system prompts that the local developer model reads on every prompt. The frontier model writes those files once and refines them on a slow cadence. The local model runs against them indefinitely.
The hardware question
The split costs nothing extra to run inside a cloud subscription, with Auto mode for routine work and Sonnet or Opus for the rest. Hardware becomes the question once routine volume keeps pushing past the cap even with that discipline.
Owning the hardware moves routine volume off the subscription without replacing it. Amortized cost is the wrong indicator for the move, because the subscription does not go away. What matters is which tier becomes sufficient once that volume has somewhere else to live.
A Mac Studio M3 Ultra with 96GB unified memory runs $3,999 and holds Qwen3-Coder-Next at Q4 quantization with room for context. As of May 2026 this is the only high-memory configuration Apple sells, with the 256GB and 512GB tiers removed in March and May respectively and delivery times running 6 to 10 weeks. The base M4 Max at $1,999, configurable up to 96GB, is the other option currently in the lineup.
The math runs against subscription page logic. A heavy individual user without a local executor ends up on Max 20x at $200 or Codex Pro at $200 because routine work fills the rate budget that should have been reserved for architect tasks. Move that volume to local hardware and Pro $20 covers what is left, because the architect tasks that remain fit inside Pro’s limits comfortably. The subscription drops a tier or two, and the hardware sits under the desk paid for once.
What’s coming next
Three threads sit on the near horizon.
Routing layers will absorb more of the usage. Auto mode is the front edge. Cursor’s Auto routes between OpenAI, Claude, and Gemini based on task heuristics. Copilot has Auto model selection. Claude Code defaults to Sonnet and escalates to Opus through configuration most teams set once. The Auto path is unmetered or cheap on every platform that has it, which is the vendors’ way of pushing routine work down to cheaper models without anyone having to choose. Premium models become the deliberate escalation, not the default.
Caching becomes the real pricing battleground. Cache reads already cost less than fresh reads on every API, and the spread is widening. Cache hits drive most of Claude Code Max’s economics. The next round of API price changes is going to make cache reads structurally cheaper still, because vendors compete on the inference cost they actually serve. Engineers and orgs that structure their workflows for cache hit rate, with stable AGENTS.md, consistent repository context, and deterministic system prompts, will pay materially less than those that flush cache on every iteration.
The open-source local-model option becomes a hedge worth keeping ready. Code completion is already free on every plan because the vendors do not pay marginal cost for it: a small model running on commodity hardware handles it. The next layer up, the routine agent steps that today bill at Sonnet or GPT-5 rates, is where local Llama and DeepSeek-class models become a real alternative.
The flat-rate AI coding subscription was always a marketing artifact of a brief moment when these tools were autocomplete utilities and the cost of serving was knowable. Agents made the cost variable, and every major vendor repriced inside twelve months.
For most developers right now, the move that pays off is deliberate model selection inside the existing subscription: Auto mode over manual frontier selection, Sonnet over Opus when you do escalate, and cache-friendly context patterns that keep input costs low. Local hardware is the hedge for people who keep hitting limits even with that discipline, or who want out of the pricing cycle entirely.
By Joshua McDonald on May 14, 2026.
Exported from Medium on August 26, 2026.
Reader discussion