The Hidden Costs of AI Coding: Tokens, Subscriptions and Vendor Lock-In

The sticker price of an AI coding tool is the least interesting number on the invoice. A $20-a-month subscription looks cheap until a weekly usage cap stops you mid-sprint; a token bill looks predictable until an agent re-reads the same files forty times; a productive workflow looks portable until you try to leave the vendor. The real cost of AI-assisted coding is a stack of mechanics — tokens, subscriptions, rate limits, lock-in and review debt — that the headline figure hides. This analysis takes each in turn, using vendors' own pricing pages where the numbers are verifiable, and flagging where they are not. All figures are in USD and current as of June 2026; pricing in this market moves fast.

How token pricing actually works

A token is a chunk of text the model processes — roughly four characters, or about three-quarters of a word in English. You pay separately for input tokens (everything you send: your prompt, the system prompt, files, tool definitions and the entire prior conversation) and output tokens (what the model writes back). Output is the expensive side, typically about 5× the input rate. Anthropic's published API rates show the pattern: Claude Sonnet at $3 per million input tokens and $15 output; Claude Opus at $5 input and $25 output. OpenAI's gpt-5.5 is $5 input and $30 output.

Coding agents burn tokens far faster than a chat session, for three compounding reasons documented in Anthropic's pricing docs:

• The context is re-sent every turn. The API is stateless, so the entire conversation — every file read, every prior tool result — is re-sent as input on each step. A long agent loop pays for its growing context again and again.
• Tool calls carry overhead. Each tool definition consumes input tokens; Anthropic documents fixed costs such as ~245 input tokens for a Bash tool call and ~700 for the text editor, and notes that reading a 100 kB document back into context is about 25,000 tokens.
• Loops re-read files. Agents read, edit, re-read and verify — each pass is fresh input.

The main lever against this is prompt caching: reusing already-processed context bills cache reads at 0.1× the base input price (a 90% discount), though cache writes cost 1.25×–2× of base input. Anthropic's own worked example drops a coding session from $0.705 to $0.525 once most input is cache hits. Both Anthropic and OpenAI also offer a 50% batch discount — but it does not apply to interactive coding sessions, which is where your money goes.

Subscriptions, caps and the pricing changes that angered users

The flat-subscription model promises predictability, and in 2025 several vendors changed the terms under their users.

Anthropic Claude offers Pro at roughly $20/month and Max plans at roughly $100 (5×) and $200 (20×), with usage shared across Claude.ai and Claude Code. The contentious move was the introduction of weekly rate limits for Pro and Max, effective 28 August 2025, layered on top of the existing rolling five-hour session limit. Anthropic said the change affected fewer than 5% of subscribers and targeted continuous, automated and shared-account use. Note that the official support pages confirm the existence and date of the weekly limits but do not publish exact hour quotas — circulating hour figures are third-party estimates, so treat them as approximate.

Cursor triggered the loudest backlash. On 16 June 2025 its $20 Pro plan switched from 500 fast requests a month to $20 of usage credits billed at the underlying API rates, then pay-as-you-go overage. Cursor's own post pegged that $20 at roughly 225 Sonnet requests. Agentic, long-context workflows that had felt unlimited now hit credit depletion and surprise overages quickly. In early July, CEO Michael Truell apologised: "We recognize that we didn't handle this pricing rollout well and we're sorry. Our communication was not clear enough." Cursor offered refunds for unexpected charges between 16 June and 4 July and introduced an Ultra plan at $200/month.

GitHub Copilot moved the other way on the model entirely. Effective 1 June 2026 it shifted from premium-request units to usage-based billing with GitHub AI Credits (charged on input, output and cached tokens at per-model rates; 1 AI credit = $0.01), while keeping code completions free and unlimited. Current individual plans are Free, Pro at $10/month ($15 in credits), Pro+ at $39 ($70 in credits) and Max at $100 ($200 in credits). Under the legacy request model, per-model multipliers rose sharply at the same cutover — press reported some agentic bills jumping 10× to 50× for power users — which is exactly the kind of mechanic the headline tier price conceals.

The pricing models, side by side

The pattern across all four: the visible monthly number is a floor, and the variable mechanic underneath — weekly caps, credit overage, request multipliers — is where the real cost lives. A flat subscription caps your spend but rations your capability and can change overnight. Pure usage billing never rations capability but never caps the bill either, which is precisely what burned Cursor's heaviest users.

Vendor lock-in: the cost you do not see until you leave

The subtler hidden cost is that the workflow you build is not portable. Each tool encodes its scaffolding in a proprietary format — Cursor's rules, Copilot's configuration, Claude Code's CLAUDE.md and agent settings. Custom agents, rules and project memory do not move cleanly between vendors, so switching means rebuilding all of it.

There are two partial counterweights. The Model Context Protocol (MCP) is an open, cross-vendor standard for connecting tools and data to any MCP-capable client; integrations built against it move between agents, reducing lock-in at the tool layer — though your prompts and agent definitions still do not. And model-switching abstractions (Copilot's model picker, Cursor's multi-model support) let you swap providers when one raises prices — though per-model billing multipliers mean the cheapest listed model is not always the cheapest billed one. The real exposure is building durable team habits, prompts and review processes on a single vendor that, as 2025–2026 demonstrated three times over, can change the pricing model under you with little notice.

The TCO line items nobody budgets for

Beyond the bill, the total cost of ownership includes work the invoice never mentions.

• Review burden. AI generates code faster than humans can review it, and the verification labour is real and uncosted. Copilot even bills its own AI code review, and self-review does not replace a human reading the diff.
• Security debt. The package-hallucination study behind the "slopsquatting" attack class tested 16 models across 576,000 code samples and found about 20% referenced packages that do not exist — over 205,000 unique fake names — each a name an attacker can register with malware. Every AI-written dependency is a thing you now have to verify.
• Token waste. Stateless re-sending of a growing context, repeated file reads and verbose output mean a multi-step agent can cost several times a tight single-shot prompt for the same result. Caching mitigates but does not eliminate it.
• The subscription-versus-API trade-off. A subscription caps spend but rations and can change; pure usage uncaps capability and the bill alike; the credits-plus-overage middle carries the worst surprise-bill risk unless overage is capped.

FAQ

Why does output cost so much more than input? Generating tokens is more computationally expensive than reading them, and the multiplier is consistent across vendors — roughly 5×. It is why verbose agent output and long generated diffs, not your prompts, dominate the bill.

Is a subscription or pay-as-you-go cheaper for me? It depends on intensity and tolerance for surprises. A subscription caps spend but imposes rate limits that can interrupt heavy use (Anthropic's August 2025 weekly caps); usage billing never rations but never caps the bill, which is what hit Cursor's power users in June 2025. Light users favour subscriptions; bursty heavy users should model both.

What is the cheapest way to cut a token bill? Prompt caching. Reusing processed context bills at about 0.1× the base input rate — a 90% discount on the repeated parts. Keeping context tight and avoiding needless file re-reads compounds the saving.

Does MCP really reduce lock-in? At the tool layer, yes — integrations built on the open MCP standard move between any compliant client. But it does not make your prompts, rules or agent definitions portable, so the workflow lock-in remains the bigger exposure.

Bottom line

AI coding is cheap to start and expensive to misjudge. The sticker price hides token mechanics that punish long agent loops, subscription terms that changed three times across major vendors in 2025–2026, and a workflow you cannot easily carry to a competitor. Treat the monthly figure as a floor, model your actual token consumption and the overage rules, lean on prompt caching, keep integrations on open standards like MCP where you can, and budget for the review and security work the invoice never shows. The tool is not the cost; the way you use it is.

Sources and further reading