AI Coding Assistant Real Cost

Every AI coding tool advertises a seat price, and every "AI coding cost" comparison repeats those seats in a tidy table. The problem is that the seat is now the smallest line on most teams' invoices. Since 2025, all four major assistants have moved to layered billing: a subscription for the base tier, a credit or usage pool that depletes, and metered billing once the pool runs dry. This page separates the three layers with numbers we checked against official pricing pages on September 24, 2026 — and shows where the "real cost" estimates from third parties actually come from.

Layer 1: official seat prices (checked September 24, 2026)

Tool	Entry paid plan	Mid tier	Heavy tier	Team seats
GitHub Copilot	Pro — $10/mo (1,000 AI credits base)	Pro+ — $39/mo (3,900)	Max — $100/mo (10,000)	Business $19 / Enterprise $39 per seat/mo
Cursor	Individual — $20/mo	Higher tiers exist but are priced around usage; Cursor's page confirms $20 and $40 explicitly		Teams — $40/user/mo
Claude	Pro — $17/mo billed annually ($200 up front), $20 monthly	—	Max — from $100/mo (5x or 20x Pro usage)	Team standard seat $20 (annual) / $25 (monthly); premium seat (5x usage) $100 / $125; Enterprise $20/seat + usage at API rates
ChatGPT	Plus — $20/mo (Go is $8/mo in the US)	—	Pro — $100/mo (5x) or $200/mo (20x)	Business/Enterprise priced per user, quote-based

Sources: GitHub's Copilot plans docs (docs.github.com), Cursor's pricing page, Anthropic's pricing page, and OpenAI's help center — each fetched directly on September 24, 2026. OpenAI's own pricing page sits behind Cloudflare and wouldn't render for us, so the ChatGPT numbers are corroborated across two independent sources instead: OpenAI's help article ("$20/month" for Plus) and CloudZero's September 4, 2026 tier rundown ($100/$200 for Pro's two usage tiers). We note that openly rather than pretending we read the pricing page.

One structural note: GitHub's new billing is credit-based. Each plan ships a monthly AI-credit pool (1,000 → 3,900 → 10,000 as you climb tiers), and premium models drain it faster. Anthropic's Team plan does the opposite — a flat seat fee plus usage billed at API rates — which is why its Enterprise line item is the only one that reads like a cloud bill. These aren't cosmetic differences; they determine which layer actually hurts.

Layer 2: why the seat price is not your bill

Three mechanisms push real spend above the seat:

• Credit pools that premium models drain quickly. Copilot's base 1,000 credits sound generous until the model you actually want costs multiples of the base rate. Heavy-tier plans ($39, $100) are mostly pre-purchased credit relief.
• Usage caps inside subscriptions. Claude's Pro and Max plans both say "usage limits apply" on the pricing page itself; Max exists specifically to sell 5x and 20x headroom. The cap is the product.
• Usage-based add-ons. Cursor's own feature list marks Bugbot as "usage-based billing," and its Individual plan's agent limits are "extended" rather than unlimited. When the fixed pool runs out, the meter starts.

This is why seat-price comparisons feel out of touch. The sticker says $10-20; the spreadsheet teams keep privately says otherwise.

Layer 3: what heavy use actually costs — third-party estimates, quoted with sources

The independent estimates disagree with each other, which is exactly why we quote them side by side instead of averaging them into a fake consensus:

Source (date)	Claim	Notes
CloudZero (Aug 28, 2026)	List prices run $0 (Copilot free tier) to $200/developer/mo; once agents run all day, vendor-reported usage lands at $100-250 per developer monthly "no matter which one you pick"	Also ranks per-task cost: Codex cheapest for ChatGPT subscribers, Claude Code "most predictable ceiling," Cursor "most variable"
GetDX (Jun 2025, article since removed from their site)	OpenAI's API can add roughly $12,000/year for a team averaging 1M tokens per developer per month	We could not re-verify this against the original article (404 as of Sep 24, 2026) — the figure comes from the indexed excerpt. Treat it as directional, not audited
Community signal (via CloudZero)	r/ClaudeAI threads like "The Absurd Math of $20 AI Coding Subs" — engineers comparing how much agent time a subscription actually buys before throttling	Secondhand, quoted for signal rather than number

The pattern across all three: light use tracks the seat price; heavy agent-driven use converges toward $100-250/developer/month regardless of vendor, because at that point you're buying compute, not a seat. Any article that quotes one number for "what AI coding costs" is silently picking a usage level for you.

The metered alternative: running the same work on DeepSeek's API

If heavy use is where subscriptions break, the honest comparison is against raw API costs. Using DeepSeek's official pricing table (checked September 24, 2026) for deepseek-flash (model version DeepSeek-V4.1-Flash, 1M context): input is $0.15 per 1M tokens on cache miss ($0.30 peak hours), $0.003 off-peak on cache hit ($0.006 peak), and output is $0.60 per 1M ($1.20 peak). Peak hours are 01:00-04:00 and 06:00-10:00 UTC, Monday-Friday; everything else bills at half price — details in our off-peak pricing explainer and context caching breakdown.

Worked example — a daily agent workload of 20M input tokens (18M hitting cache, 2M missing) plus 1M output tokens, run off-peak:

• Cache-hit input: 18M × $0.003 = $0.054
• Cache-miss input: 2M × $0.15 = $0.30
• Output: 1M × $0.60 = $0.60
• Daily total: $0.954 → roughly $28.6 per 30-day month.

Push the same volume through peak hours with zero cache hits and it's 20M × $0.30 + $1.20 = $7.20/day, about $216/month. That spread — $29 to $216 for identical volume — is the honest framing of "how much does the API route cost": it's a function of cache-hit rate and scheduling, not a fixed number. It also brackets CloudZero's $100-250 heavy-use estimate from both sides, which is a useful sanity check: the metered route is competitive with heavy subscription use, dramatically cheaper if you can schedule work off-peak and structure prompts for cache hits, and more expensive if you can't. For model-vs-model pricing math, see GLM 5.3 Flash vs DeepSeek V4.1 Flash.

(Caveat: our worked example is arithmetic on official rates, not a measured bill — we don't run a fleet of agents. The token volumes are stated so you can substitute your own.)

So what should you actually pay?

• Under ~1 hour of AI help a day: buy the cheapest seat covering the models you need — Copilot Pro at $10 is the floor, ChatGPT Go at $8 if $10 matters. Ignore "real cost" think-pieces; they don't describe you.
• Agents running daily, multi-hour sessions: assume $100-250/developer/month in practice (CloudZero's vendor-reported band). Compare tools on ceiling predictability, not sticker: Claude's usage-capped plans have the most predictable ceiling; Cursor's usage-based billing is the most variable.
• Batch-able, schedulable workloads: price the API route before renewing seats. With an 80%+ cache-hit rate and off-peak scheduling, DeepSeek-flash-class models undercut the heavy tiers by an order of magnitude on input-heavy work — our caching guide shows the mechanism, and free-tier APIs cover the light end entirely.