AI Coding Price Comparison 2026: Real Cost Per Dev

This AI coding price comparison opens with the cheapest working setup in August 2026: GitHub Copilot Free plus a BYOK open-source CLI agent, $0 in software with model tokens billed at cost. The cheapest paid ticket from a major vendor is Copilot Pro at $10/month. Five plans crowd the $20 tier. Cursor Pro, Claude Code Pro, Windsurf Pro, Augment Indie and v0 Premium all sit there and buy wildly different amounts of frontier-model compute. Heavy solo users converge on $200/month across four vendors. Teams should ignore all of that and budget $200 to 600 per engineer per month all-in, because seat price predicts less than half of real spend once credits, overages and required adjacent products land.

Prices in this article were captured from vendor pricing pages on [DATE, set at publish]. Every figure below carries a verification date. AI coding pricing changed materially at least nine times in the 18 months to August 2026. Read the changelog section before you act on any number here, including mine.

The short answer: cheapest AI coding tool at every budget

$0 that actually works. GitHub Copilot Free gives 2,000 code completions and 50 premium requests per month [VERIFY against GitHub’s pricing page]. That ceiling holds for a student, a hobbyist, or someone using AI for occasional autocomplete. It collapses the first day you point an autonomous agent at a real repository. Fifty premium requests is roughly two serious multi-file tasks. Pair it with Aider, Cline or OpenCode on your own API key and the software cost stays at zero while the model cost becomes whatever you spend.

Best paid entry. Copilot Pro at $10/month is the lowest paid ticket in the market. You give up three things: an AI-native editor (you stay in VS Code or a JetBrains IDE with an extension), an uncapped agent allowance, and predictable overage. Extra premium requests bill per request once the allocation runs out.

The $20 cluster. Five plans share this price and none of them buy the same thing. Cursor Pro gives you a dollar-denominated credit pool plus Auto mode. Claude Code Pro gives you refilling token windows on a clock. Windsurf Pro, formerly Codeium and restructured in March 2026, gives you daily and weekly quotas. Same sticker, different physics.

Heavy individual use. Cursor Ultra, Claude Max 20x, Windsurf’s top tier and ChatGPT Pro all land at $200/month. That number is not a coincidence. It approximates what a heavy agentic user would spend on $600 to 1,500 of equivalent API tokens at published list rates [VERIFY the multiple against Anthropic’s published API pricing and Max tier disclosures], so vendors have converged on it as the point where a subscription still beats metered billing for them and for you.

Teams. Cheapest flat rate and cheapest effective rate are different answers. Amazon Q Developer Pro at $19/user/month and GitHub Copilot Business at $19/user/month set the flat-rate floor. Copilot Enterprise’s advertised $39 seat is not the real Enterprise price, for reasons covered below.

One caveat runs through everything. The sticker is a floor, not a price.

The master AI coding price comparison table: 14 tools, every tier, dated

Rule for this table: every cell must trace to the vendor’s own pricing page, captured on a stated date. No figure here is carried over from another comparison article. Where a vendor publishes no number, the cell says “Custom, not disclosed” rather than an estimate.

Visual needed: Master pricing table rendered as a sortable 14-row × 10-column HTML table, covering free tier (exact limit), entry paid, mid tier, top individual tier, team $/seat, enterprise $/seat, billing unit, overage mechanic, annual-only?, price verified on. Every row carries its own capture date and a link to the vendor pricing page. Data captured directly from vendor pricing pages on a single day.

Tool	Free tier	Entry paid	Top individual	Team $/seat	Billing unit	Annual-only?
GitHub Copilot	2,000 completions + 50 premium req/mo [VERIFY]	Pro $10	Pro+ $39	Business $19	Premium requests / AI Credits	No
Cursor	Limited trial	Pro $20	Ultra $200	Teams $40	Dollar-denominated credits	No
Claude Code	None (API only)	Pro $20	Max 20x $200	Team Premium, see contradiction audit	Token windows on a clock	No
Windsurf	Limited	Pro $20 (was $15 pre-19 Mar 2026)	Top tier ~$200 [VERIFY]	Teams, vendor page	Daily/weekly quotas	No
OpenAI Codex / Codex CLI	CLI free, BYOK	ChatGPT Plus $20	ChatGPT Pro $200	Business, vendor page	Included quota + API	No
JetBrains AI + Junie	Free tier w/ limited quota	AI Pro [VERIFY]	AI Ultimate [VERIFY]	Per-seat	Quota credits	Discount for annual
Gemini Code Assist	Individual tier ending 18 Jun 2026 [VERIFY]	Standard [VERIFY]	Enterprise [VERIFY]	Per-seat via Google Cloud	Seat + GCP usage	No
Tabnine	Trial only	Dev $39/user/mo (contested, see audit)	Enterprise $59 [VERIFY]	$39 to 59	Flat seat	Yes, no monthly option
Amazon Q Developer	Free tier w/ agentic request cap	Pro $19/user	None	$19	Flat seat + request allowance	No
Augment Code	Limited	Indie $20	Higher tiers + auto-top-up	Per-seat	Credit pool	No
Qodo	Free tier	Teams tier [VERIFY]	Enterprise custom	Per-seat	Per-seat + usage	No
Sourcegraph Cody	None public	Custom, not disclosed	Custom	Enterprise from $16,000/yr per one comparison [VERIFY]	Enterprise contract	Effectively yes
Replit	Free w/ limited agent runs	Core $20 [VERIFY]	Higher tiers	Teams	Credits + compute	No
Bolt.new	Token-denominated free tier, daily cap binds first	Pro $20 [VERIFY]	Higher token tiers	Teams	Raw tokens	No
Aider / Cline / OpenCode	Software free (MIT/Apache)	$0	$0	$0	Your API bill	N/A

Two columns nobody else publishes belong here. Annual commitment required matters because Tabnine has no monthly option and Sourcegraph Cody publishes only an annual enterprise figure. In a market this volatile, a 12-month lock is a real risk transfer. Grandfathering policy matters more. Windsurf grandfathered existing subscribers through the March 2026 quota change [VERIFY against Windsurf’s announcement], which is the only public price-lock commitment I can point to among the major vendors. Everyone else reserves the right to reprice you at renewal, and most of them have used it.

Why these prices don’t compare: the five billing models

Any AI coding price comparison that stops at the sticker is putting five different products in one column. Five mechanisms are in play, and four of them deliberately obscure the underlying unit of consumption, which is tokens.

Flat seat. Amazon Q Developer Pro and Tabnine sell you a seat with soft-capped access. Most predictable, usually least capable at the frontier end. You will rarely get a surprise invoice and you will rarely get a frontier-model agent running for six hours.

Premium requests. GitHub Copilot leaves inline completions unmetered and meters everything that touches a frontier model. Each plan carries a monthly allocation; overage bills per request. The allocation number on its own is meaningless, because each model carries a multiplier. One call to a heavyweight reasoning model can consume several requests from your allocation while a cheap model consumes a fraction of one. A plan advertising 300 premium requests might deliver 60 real agent turns or 900, depending entirely on model choice.

Credit pool. Cursor, Augment Code and v0 sell a denominated balance that drains at model-specific rates. A credit is not a request. The identical prompt run against a frontier model versus a cheap one can differ by 3 to 5x in drain. The pool model permits bursting: you can spend your whole month in a day if a refactor demands it, and then you are done.

Quota windows. Windsurf and Claude Code refill capacity on a clock rather than holding a balance. Unused capacity does not bank. Burn your window by 11am and you wait for reset. That is a fundamentally different failure mode from a pool: you are not exposed to overage, you are exposed to being locked out mid-task.

Raw tokens. APIs and BYOK tools charge published input and output rates with no ceiling whatsoever. Aider, Cline, OpenCode, Continue, Codex CLI and Bolt.new all work this way. Maximum flexibility, maximum exposure. An agent loop that fails silently at 2am bills the whole time.

The next section converts all five back to tokens.

Normalizing everything to $ per million tokens

This is the arithmetic every AI coding price comparison declines to do. The method is simple and auditable: take each vendor’s own published quota or credit disclosure, take the published API list price of the model that quota is spent against, and compute an implied dollars-per-million-tokens rate for the subscription.

State the limits before the results. This is a published-pricing model, not a measurement. I have not run these tools or counted tokens. Vendor quota disclosures are approximate and sometimes described in ranges. Models differ in token efficiency for the same task. Prompt caching can move real consumption by a multiple. Treat the output as a way to rank plans on the same axis, not as a bill forecast.

Visual needed: Hero scatter plot with monthly plan price on the x-axis ($0 - $200), implied cost per million tokens of frontier-model work on the y-axis, one dot per plan, colour-coded by billing model (flat seat / premium requests / credit pool / quota window / raw tokens). Conversion arithmetic documented in a footnote. Visible label: “derived from published pricing, not measured.” Data: each vendor’s pricing page plus Artificial Analysis model comparison.

Worked example 1, Claude Code Max. Anthropic publishes both its API per-MTok input and output rates and an approximate description of what each Max tier’s session windows deliver. Divide the subscription price by the token volume the published windows imply, and compare that quotient to the API list rate. The gap is the subscription discount. For a heavy user who saturates the windows, the implied rate lands well below list. That is the honest reason $200/month exists. Anthropic is selling tokens at a discount to users who buy in bulk and eating the variance. Show your own arithmetic: (monthly price) ÷ (published window tokens × sessions per month ÷ 1,000,000) = implied $/MTok. [VERIFY the current Max window disclosures and API rates against Anthropic’s pricing page before publishing a number.]

Worked example 2, Cursor Pro. Because Cursor’s pool is dollar-denominated, the implied rate is close to pass-through at model list price. Twenty dollars of credits buys roughly twenty dollars of tokens, minus whatever margin sits in the conversion. Auto mode breaks this. When Cursor routes a task to a model it selects, the cost stops tracking your usage in the same way. That makes Auto mode arguably the most consequential pricing feature any vendor shipped in this cycle, because it decouples spend from consumption for the subset of work it handles. How large that subset is on a real codebase is exactly the kind of question that requires instrumented hands-on measurement, and nobody has published it.

Worked example 3, Copilot Pro. Convert the premium-request allocation into token-equivalents using the published per-request overage price as the anchor. If a premium request costs a fixed amount in overage, and a typical agent turn consumes a knowable token volume at frontier rates, you can back out what the allocation is worth. The result: $10 is genuinely cheap if your workflow is completion-heavy, because completions are unmetered. It is not cheap at all if you run agents, because agents spend premium requests fast and overage is per-request.

Independent reference data on the underlying model economics sits at Artificial Analysis model comparison, which publishes price per million tokens and cost to complete a standardized task across 179+ evaluated models. Their provider pricing changelog logs pricing and performance updates landing multiple times a week, with entries on 5, 6 and 7 August 2026 alone. That cadence is the single best argument for dating every price cell on a page like this one.

Three usage profiles: what you actually pay

Vague profiles produce vague numbers. Here are three defined precisely enough to argue with.

• Light: inline completions all day, plus 3 to 5 chat sessions. No autonomous agents.
• Steady: 2 to 4 agent tasks per day on a mid-size repository, plus completions.
• Heavy: all-day agentic work, multi-file refactors, large context loads, several parallel sessions.

Visual needed: Effective monthly cost by usage profile, 8 rows (most-searched tools) × 3 columns (Light / Steady / Heavy), each cell showing base price and expected overage/top-up as two separate figures so the reader sees where the sticker breaks down. Derived from the normalization model plus each vendor’s published top-up and overage rates; profile assumptions restated in the table caption.

The crossover points are where the money is. Copilot Pro’s per-request overage is benign at Light usage and starts to exceed Cursor Pro’s flat pool somewhere in the Steady band. The exact point depends on your model multiplier mix, which is why the multiplier matters more than the allocation. A more common failure: a Steady-to-Heavy user on a $20 plan who tops up repeatedly and ends the month above what the $100 or $200 tier would have cost. Check your top-up history before renewing.

The quota-model trap deserves its own paragraph, because no pricing page describes it. On Windsurf or Claude Code, a heavy user’s bill does not rise. Their throughput falls. You hit the window, you stop, you wait. You pay in blocked hours, not dollars. That cost never appears on an invoice and never appears in a comparison table, and it is entirely real if you are billing a client or shipping to a deadline.

At the enterprise end, one credible published datapoint exists. Anthropic’s reported enterprise deployment figures put average consumption at $13 per developer per active day and $150 to 250 per developer per month, with 90% of users below $30 per active day (DX, AI coding assistant pricing). Label this precisely: it is first-party vendor data about the vendor’s own product, describing customers who chose to deploy it. Treat it as a floor for what committed users spend, not as a forecast for your org.

The number most AI coding price comparison pages bury: teams running both an inline tool and an agentic tool, which is the common configuration rather than an exotic one, land at a realistic all-in figure of $200 to 600 per engineer per month. That is 5 to 20x the seat price most finance teams budgeted.

Subscription vs API vs BYOK: where the break-even actually is

Visual needed: Break-even chart with monthly token volume on the x-axis, monthly cost on the y-axis, one line each for Pro subscription, top-tier subscription, API pay-as-you-go, BYOK with caching at a 20%-of-uncached hit rate, and BYOK on a cheap open-weights model. Crossover points annotated. Data: published per-MTok rates, published subscription prices and quota disclosures, plus the cache-hit rate reported in this Hacker News comment, labelled as one provider’s published rate.

The structural answer first: subscriptions sell tokens below list to heavy users and above list to light users. APIs win for bursty or occasional work. The crossover is a token volume, and you can compute it from published rates. Divide the subscription price by the API’s blended per-MTok rate for your input/output mix, and that quotient is the monthly token volume above which the subscription pays for itself.

Prompt caching is the lever nobody in the top ten mentions. A practitioner on Hacker News describes the economics directly: “On Fireworks AI, for example, if it hits the cache, you pay only 20%. And uncached is just $0.14/M tokens for DSV4-0731 … I get entire re-architecture projects (with new tests and documentation) done for mere dollars” (Hacker News comment on cache pricing). Agentic coding is unusually cache-friendly, because the same repository context gets resent on every turn. An 80% discount on the majority of your input tokens moves a BYOK bill by several multiples. No subscription plan exposes this lever to you at all. The vendor captures the caching benefit, not the customer.

The alternative-provider route is being actively taken by operators. One writes up exactly this decision under the title “Reallocating $100/Month Claude Code Spend to Zed and OpenRouter,” noting: “It turns out some of the cheapest providers with the highest limits are ones you might not have heard of. OpenCode Go has the simplest plan at the highest rate limits for any subscription plan with multiple model families” (Hacker News discussion). That is one operator’s account of one reallocation, not a benchmark. It is also the kind of evidence that never appears in a comparison built only from vendor pricing pages.

Token efficiency as a price multiplier. OpenAI has claimed Codex CLI is roughly 4x more token-efficient than Claude Code (claim surfaced by nxcode). Label it accurately: this is a vendor claim about a competitor’s product. It is marketing. No independent replication is publicly available, and if it were true at that magnitude it would dominate every other pricing consideration on this page. Verifying it requires controlled runs with instrumented token counting on identical tasks. That work has not been published by anyone, and I have not done it.

The largest single cost lever remains model choice. The same agent harness running a frontier model versus a cheap open-weights model differs by an order of magnitude in $/MTok. Compare the price and cost-per-task columns at Artificial Analysis to see the spread.

One operational rule: set a hard spend cap on any API key an autonomous agent can reach. Agent loops fail expensively and quietly.

The hidden line items: what the pricing page doesn’t show you

Every AI coding price comparison built from pricing pages alone stops here. The costs below are real and none of them are advertised.

Visual needed: Hidden-cost stack diagram with a $39 seat drawn as a stack of layers: seat, required adjacent product, add-on modules, agentic compute, overage/top-ups, self-hosting infrastructure, switching cost. Layers with a published price are sized to scale; layers with no published figure are drawn as unsized bands labelled “not disclosed.”

Required adjacent products. Copilot Enterprise’s $39 seat requires GitHub Enterprise Cloud at an additional $21/user/month, making the effective seat $60 (reported by DX; verify against GitHub’s own pricing page). This is the most commonly missed number in enterprise AI budgeting, and it is a 54% understatement if you miss it.

Add-ons marketed as features. Cursor’s Bugbot PR review costs an additional $40/user/month on top of the base seat (ijonis pricing roundup; verify against Cursor’s pricing page). On a $40 Teams seat that is a 100% increase for one capability.

Compute billed separately. Agentic Copilot workflows consume GitHub Actions minutes on top of the subscription. Those minutes are a separate line on a separate invoice, and they scale with agent activity rather than headcount.

Promotional credits masking the baseline. Business plans have been reported as carrying an extra $30/user/month in credits and Enterprise an extra $70/user/month through August 2026 (reported by DX; verify against GitHub’s own announcement before acting). If that is accurate, the first unsubsidized invoice lands in September. Next month, as of writing. To stress-test your Q4 number: take your last full month’s usage, subtract the promotional credit from your available balance, and reprice the overage at published rates. Do it now rather than in October.

Self-hosting infrastructure. On-prem and air-gapped deployments carry GPU and host costs absent from every per-seat quote. The failure-mode section below documents what the client-side resource footprint has historically looked like on one major vendor’s tracker; the server side is yours to size and pay for.

Top-up pricing as effective overage. Augment’s auto-top-up and Windsurf’s credit packs mean the advertised tier is a floor. Take the published top-up rate, convert it to an implied per-credit price, and compare it against the base tier’s implied rate. If the top-up rate is worse, and it usually is, repeated top-ups are a signal to move up a tier rather than a cost-saving.

Switching cost, which no vendor prices. Migrating configuration across .cursorrules, CLAUDE.md, AGENTS.md and .github/copilot-instructions.md, retraining a team on a different agent’s behaviour, and absorbing the productivity dip during changeover are all real one-time costs. They are the reason annual commitments are riskier than the discount suggests: the lock-in is not just the contract.

How volatile is this? An 18-month pricing changelog

Visual needed: Horizontal timeline of the 18 months to August 2026, one marker per material pricing change, colour-coded increase / decrease / structural change, with grandfathering noted per marker. Every marker sourced to a vendor announcement, vendor changelog or archived pricing-page snapshot.

Date	Tool	What changed	Direction	Grandfathered?
Mid-2025 [CONFIRM EXACT DATE]	Cursor	Request-based billing → dollar-denominated credit pool	Structural	[VERIFY]
2025 [CONFIRM]	GitHub Copilot	Tiered premium request limits introduced	Structural / restriction	[VERIFY]
19 Mar 2026	Windsurf	Credits → daily/weekly quotas; Pro $15 → $20	Increase + structural	Yes, existing subscribers grandfathered (reported by nxcode; verify against Windsurf’s own announcement)
1 Jun 2026	GitHub Copilot	Transition to token-based AI Credits billing reported as completing	Structural	[VERIFY] (reported by DX)
18 Jun 2026	Gemini Code Assist	Individual and free tier ending	Removal	[VERIFY against Google’s announcement]
Q2 2026 [CONFIRM]	Cline	Teams tier moves free → paid	Increase	[VERIFY]

Every row above needs its primary source confirmed before publication: a vendor announcement, a vendor changelog, or an archived snapshot of the pricing page. Where only a secondary source exists, the row says so.

Count the entries and the pattern is unmissable. The overwhelming majority are price increases, capability reductions or structural changes that make cost harder to predict. I can find no material price decrease among the tracked tools in this window [VERIFY before publishing that claim].

Two conclusions follow. Annual commitments in this category carry unusual risk, because you are locking your price while the vendor retains the option to change what that price buys. And any AI coding price comparison published without a per-cell verification date should be treated as unreliable, because the half-life of a number in this market is measured in months.

Where the billing models break: evidence from public issue trackers

A plan’s price only means something if the product runs. Public issue trackers are where the cost model and the software collide, and no AI coding price comparison in this SERP cites a single one.

Visual needed: Annotated screenshot of TabNine issue 43 and issue 183 showing reaction counts and issue dates, with the capture date stamped in the caption so the evidence reads as verifiable and clearly historical.

Local inference has a hardware cost that never appears on the invoice. Tabnine’s public client repository carries a long-running cluster of resource-consumption reports. “High memory and CPU usage” has 273 reactions, with the reporter observing 100% CPU for extended periods while working on rustc, including when not actively editing (TabNine issue 43). “TabNine consumes excessive CPU for extended periods” has 128 reactions, describing 100 to 120% CPU much of the time in SublimeText on macOS (TabNine issue 24). “Insane CPU & RAM use, even when idle” has 78 reactions on VS Code (TabNine issue 257). A vim user reports 1.37 GB of memory consumed on an empty editor at startup, 72 reactions (TabNine issue 183). These are historical reports against a specific client, and they are not a claim about current builds. They are a claim about what “runs locally” can cost in machine capacity you already paid for.

Repository health is a purchase signal when you are signing an annual-only contract. The facts: codota/TabNine has 10,781 stars, 0 open issues, an MIT licence, and a last push dated 2025-09-04 (codota/TabNine on GitHub). Zero open issues on a repository with that much historical traffic does not mean the problems were solved. It means the tracker was closed or triaged to zero. Weigh that against a $39 to 59/user/month commitment with no monthly escape hatch.

Credit systems have spawned a circumvention ecosystem, and that is itself pricing evidence. BasicProtein/AugmentCode-Free, a tool for resetting Augment Code device and account state, has 1,961 stars, 47 open issues, an MIT licence, a last push of 2025-08-24 and a v2.0.4 release dated 2025-08-22 (BasicProtein/AugmentCode-Free on GitHub). Read it strictly as a market signal about how hard usage limits bite. Do not use tooling of this kind: it breaches vendor terms, exposes you to account termination and contract liability, and running unvetted binaries that manipulate authentication state is a security risk in its own right.

Vendors are rationing access geographically, and availability is a pricing variable. Issue #38 on that repository, 18 reactions, surfaces the vendor message: “Due to increased demand, we’re limiting signups in certain regions to maintain performance for existing customers” (AugmentCode-Free issue 38). A plan you cannot sign up for has an infinite effective price. For a developer in a rationed region, an entire column of the master table is unavailable at any price.

Platform coverage is a hidden switching cost. The JetBrains support request on the Tabnine tracker drew 450 reactions, the highest-signal item on the tracker (TabNine issue 13). An arm64 build request drew 110 (TabNine issue 65). If your team lives in IntelliJ IDEA or runs ARM hardware, half the price table is irrelevant before you compare a single number.

Cloud dependency is a failure mode you are billed for. “Establishing connection to TabNine Cloud is not completed” carries 77 reactions (TabNine issue 120). Every cloud-metered plan bills you for a service whose uptime you do not control and whose outages do not pause your quota clock.

Demand for the alternative is measurable. Tabby, a self-hosted Copilot alternative, drew 753 points on Hacker News with privacy and security cited as the motivation (Hacker News thread).

The contradiction audit: why published comparisons disagree

Four figures are currently published in mutually incompatible forms by pages ranking for this query. This is not a gotcha. It is a demonstration that an undated AI coding price comparison decays.

Disputed figure	Source A	Source B	Likely explanation
Windsurf Pro	$15/mo (ijonis, dated March 2026)	$20/mo, “was $15” (nxcode, describing the 19 Mar 2026 overhaul)	Both honest; A predates the overhaul. Only B is current.
Claude Code team pricing	$30/user/mo, minimum 5 seats (ijonis)	$100/seat/mo Team Premium, 5-seat minimum (DX)	Two different SKUs conflated as one. Ask sales: “Which tier includes Claude Code usage, and what is the per-seat token allocation on each?”
Copilot billing mechanic	Premium requests with $0.04 overage (nxcode)	Completed transition to token-based AI Credits as of 1 Jun 2026 (DX)	If the transition happened, A’s entire cost model no longer applies.
Tabnine entry price	$12/user/mo Dev tier (DX)	$39/user/mo annual-only floor (nxcode and Axify)	A three-fold gap. Resolve against Tabnine’s own pricing page and record the capture date.

Sourcegraph Cody adds a fifth. One page publishes enterprise pricing from $16,000/year with no smaller public plan (Axify) while others omit Cody’s pricing entirely.

The verification routine that resolves all of these takes about ninety seconds per tool. Open the vendor’s own pricing page. Check for a regional or currency variant, because the USD page is not always what you will be charged. Read the fine print for minimum seat counts, annual-only terms and what happens to unused credits at renewal.

Never buy from a blog table. Including this one. Use it to know what to look for on the pricing page.

Free tiers: what they actually get you before they stop

Free tier	Published limit	Survives Light usage	Survives Steady usage
GitHub Copilot Free	2,000 completions + 50 premium requests/mo [VERIFY]	Most of a month	~2 working days of agent use
Amazon Q Developer	Agentic request allowance [VERIFY exact number]	Days, not weeks	Under a day
Bolt.new	Token-denominated, daily cap binds before monthly	Casual prototyping only	Hours
Gemini Code Assist individual	Ending 18 Jun 2026 [VERIFY]	None	None
Aider / Cline / OpenCode / Codex CLI	Software free forever	Unlimited	Unlimited

Copilot Free is the most generous among IDE-integrated tools. Bolt.new is the most generous among app builders, but state the daily cap when you evaluate it, because the daily cap binds long before the monthly one. Amazon Q’s free agentic allowance runs out fast for anyone doing real work.

BYOK agents are the honest special case: the tool costs $0 and the model costs whatever you consume. Continue and Roo Code sit in the same MIT and Apache-licensed bracket as Aider, Cline and OpenCode, with identical economics. That is not a free tier. It is a zero-cost wrapper around an unbounded bill, and the caching and cheap-model levers above are how you control it.

Gemini Code Assist’s individual tier ending (reported 18 June 2026; verify against Google’s announcement) is the cautionary case. Free tiers are the first thing cut when unit economics tighten, and they are cut with weeks of notice, not months.

Free tiers work for learning and occasional use. They stop working the moment you point an autonomous agent at a repository you get paid for.

Team and enterprise math: 5, 50 and 500 developers

5 developers. Mostly a seat-price comparison, and flat-rate options win on predictability. Copilot Business at $19/seat is $1,140/year. Cursor Teams at $40/seat is $2,400/year before Bugbot. Add Bugbot at $40/user/month and Cursor Teams becomes $4,800/year, more than four times the Copilot Business line. Claude Team pricing is the contested figure in the audit above. Get it in writing.

50 developers. This is where the Copilot Enterprise effective-seat issue reorders the ranking. At the advertised $39, 50 seats is $23,400/year. At the effective $60 with GitHub Enterprise Cloud, it is $36,000/year. That $12,600 annual gap appears in no vendor comparison. If Amazon Q Pro’s capability fits your work, $19 × 50 × 12 = $11,400/year is the lowest fully-loaded TCO in the flat-rate class. If it doesn’t fit, that saving is fictional.

500 developers. Overheads invisible at small scale become line items: codebase indexing infrastructure, compliance and audit tooling, SOC 2 evidence collection, enablement and training time. One ranking page puts these at $50,000 - $250,000/year (DX). That range carries no source or methodology and appears on a vendor blog. Treat it as a prompt to demand a real quote, not as a benchmark.

The threshold trap. Pylon’s CEO reported the company’s Anthropic bill tracking from $400K to $1.4M annually, driven by crossing a seat threshold that triggered a tier change rather than by usage growth, alongside “$4,000 in three days in Claude Code” and top support-team spenders at $800/month (reported by DX). That is reported operator commentary, not audited financials. It is also the single most actionable warning on this page: get the tier boundaries in writing before you sign, and ask what happens when you cross one mid-term.

Procurement checklist, in the order these bite: minimum seat counts, annual-only terms, true-up mechanics when headcount grows, price-lock and grandfathering commitments in writing, overage caps and whether they are hard or soft, and what happens to unused credits at renewal.

Does the cheapest option actually cost you more? The ROI reality check

Price only matters relative to output, and the published evidence on output sits far below vendor marketing.

The best available large-sample number: a longitudinal analysis across 400+ organizations tracked over 14 months reports a median PR throughput gain of 7.76%, with most organizations in the 5 to 15% band, against vendor claims of 3 to 10x (DX). Label the source honestly. This is first-party research published by a vendor that sells engineering-measurement software. It is neither neutral nor worthless. It is the largest published sample available on the question, and it should be cited as such.

Why the gap exists is structural, not a criticism of the tools. Coding is approximately 14% of a developer’s day per the Microsoft research cited in that analysis [trace to the Microsoft primary source before publishing]. Halving the time spent typing code cannot produce order-of-magnitude throughput gains when typing code is a seventh of the job. Time saved writing is frequently reabsorbed by time spent reviewing what the model wrote.

Turn it into a pricing rule. Assume a fully-loaded engineer cost of $200,000/year, or roughly $16,700/month, and substitute your own number. A 7.76% throughput gain is worth about $1,295/month in output. Against a fully-loaded tool spend of $400 to 600/engineer/month, that clears break-even by roughly 2 to 3x. At a $100,000 loaded cost, the same 7.76% is worth $647/month, and a $600 spend clears by a hair. The tool is cheap relative to a senior engineer and marginal relative to a junior one in a low-cost region. That is the actual shape of the ROI question.

Risk belongs in the budget. Reported Amazon incident data describes AI-generated code contributing to outages, with approximately 120,000 lost orders in one incident and a 99% drop in North American orders in another, followed by a 90-day safety reset and mandatory two-person review across 335 Tier-1 systems (reported by DX). This is a secondary-sourced claim. Trace it to a primary report before repeating it, or drop it.

This page prices plans. It does not benchmark quality. For capability comparison, use independent model evaluation, and accept that no page, this one included, can tell you which tool suits your codebase without a trial on your codebase.

Decision matrix: which plan for which situation

Visual needed: Decision matrix rendered as a 10-row grid, one row per situation, with the recommendation, runner-up, monthly cost band and flip condition in separate columns. Cost bands sourced to the master table so every figure inherits its capture date.

Situation	Pick	Runner-up	~$/mo	What flips it
Solo dev on a budget	Copilot Free + BYOK CLI agent	Copilot Pro $10	$0 to 10	You start running agents daily
Solo dev, all-day agentic	Claude Max 20x or Cursor Ultra	Windsurf top tier	$200	You’d rather bank capacity than refill it, so pool beats quota
5-person startup	Copilot Business	Cursor Teams	$95	Team needs an AI-native editor
50-person org on GitHub	Copilot Business ($19) not Enterprise	Cursor Teams	$950	You need Enterprise-only governance, then budget $60/seat
50-person org on AWS	Amazon Q Developer Pro	Copilot Business	$950	Q’s agent capability doesn’t cover your work
50-person org on Google Cloud	Gemini Code Assist (paid tiers)	Copilot Business	Custom	The individual-tier withdrawal signals roadmap risk
JetBrains-only shop	JetBrains AI + Junie	Copilot (JetBrains plugin)	$20+	Check native support first; 450 reactions on that request show why
Regulated / air-gapped	Self-hosted (Tabby class) + Tabnine Enterprise	Sourcegraph Cody Enterprise	Custom + GPU	GPU cost exceeds the seat saving
ARM or unusual platform	Whatever has a native build	None	Varies	110 reactions on the arm64 request; availability beats price
Maximum data sovereignty	Self-hosted with zero data retention	BYOK to a ZDR-committed API	Custom	Your compliance team accepts a cloud DPA

Disqualifiers worth naming out loud. Terminal-only agents are wrong for teams that need GUI diffing in review. Editor-fork tools are wrong for teams with proprietary VS Code extensions that won’t port. Cloud-only tools are wrong for zero-data-retention requirements, full stop. Any tool without a JetBrains or ARM build is wrong for shops on those platforms regardless of price.

Budget for two tools, not one. An inline completion tool plus an agentic tool is the standard configuration for teams doing real work, and discovering that in month three means renegotiating a budget you already defended. Price both from the start.

Frequently Asked Questions

What is the cheapest AI coding tool in 2026?

GitHub Copilot Pro at $10/month is the lowest-priced paid plan from a major vendor. The cheapest working setup is Copilot Free plus a BYOK open-source CLI agent, at $0 in software with model tokens at cost. “Cheapest” inverts at high usage: above roughly Steady-profile consumption, flat-rate and quota plans beat per-request billing. Verified [DATE].

Why did my AI coding bill suddenly jump?

Four causes, in rough order of frequency. A billing-model migration by the vendor (Copilot’s move to token-based AI Credits, reported as completing 1 June 2026). Promotional credits expiring. Crossing a seat or usage tier threshold, as with Pylon’s Anthropic bill reportedly tracking from $400K to $1.4M annually on a tier change alone (DX). Or an agent loop burning tokens unattended. Remedies: read the vendor changelog, reprice without promo credits, get tier boundaries in writing, set hard spend caps.

Is it cheaper to use a subscription or pay per token via the API?

Subscriptions sell tokens below list price to heavy users; APIs win for light or bursty use. The crossover is a token volume: divide the subscription price by your blended per-MTok API rate. Prompt caching moves that break-even substantially, with cache hits reported at 20% of the uncached rate on at least one provider (Hacker News). Agent-heavy API use without spend caps is the main way this goes wrong.

What is a “premium request” and how is it different from a credit?

A premium request is one metered call against a monthly allocation, weighted by a model multiplier. A credit is a denominated balance that drains at model-specific rates. The practical consequence: an allocation of 300 premium requests tells you nothing until you know the multiplier, because a heavyweight model can consume several requests per call while a cheap one consumes a fraction.

How much should a team of 50 developers budget for AI coding tools?

Seat-only: $11,400 to 36,000/year depending on plan. Fully loaded: $200 to 600 per engineer per month, or $120,000 to 360,000/year, if you run both an inline and an agentic tool. The gap is the point. Copilot Enterprise’s $39 seat requires GitHub Enterprise Cloud at $21/user/month, making it $60 effective. Ask vendors in writing about tier boundaries, overage caps and unused-credit treatment at renewal.

Are free AI coding tiers actually usable?

Yes, with a hard ceiling. Copilot Free’s 2,000 completions and 50 premium requests survive a month of light use and about two days of agent use. Free tiers are the first thing cut when unit economics tighten. Gemini Code Assist’s individual tier ended 18 June 2026 as reported. BYOK open-source agents are free software with unbounded model costs.

Is annual billing worth the discount on AI coding tools?

The typical discount is 15 to 20% (Cursor Pro $20 → $16/month, Copilot Pro $10 → $8.33/month). Weigh it against documented volatility: at least six material pricing or billing-model changes across major tools in 18 months, nearly all increases or restrictions. Tabnine and Sourcegraph Cody offer no monthly option at all. The deciding question is whether the vendor commits in writing to grandfathering.

Which AI coding tool is cheapest for JetBrains or ARM users?

Answer platform support before price. Several tools have no native JetBrains or ARM build, so the cheapest option is whichever runs at all. The demand signal is documented: 450 reactions on the JetBrains support request and 110 on the arm64 build request. Among tools with native support, JetBrains AI and Copilot’s plugin are the entry-price options.

---

Open question this page cannot close. Nobody has independently verified the token-efficiency claims (Codex CLI versus Claude Code) or measured how fast a given credit pool drains on a real repository under a defined workload. That requires controlled hands-on runs with instrumented token counting on identical tasks across tools. No such study is publicly available, and nothing on this page substitutes for one.

Corrections. Every price in this AI coding price comparison is derived from published vendor pricing and public documents, not from measurement. If you are a vendor and a figure here is stale or wrong, send the pricing-page URL and the effective date and it will be corrected with the change logged below.

Related reading: AI code review tools · GitHub Copilot vs Cursor · Claude Code pricing tiers · Free AI coding tools · BYOK coding agents · Cap AI coding spend · Self-hosted AI coding tools · AI coding pricing changelog · AI coding productivity data