A deep look at the economics of coding‑with‑LLMs reveals that the token usage required for serious software work far outstrips the cheap‑per‑token pricing shown to customers. Subscription plans hide a massive subsidy, and at API rates a single complex coding task can cost dozens of dollars – enough to make the promised “killer app” financially untenable for most developers.
Anthropic and OpenAI’s Hidden Cost: Over $1,000 for Every $100 You Pay
*TL;DR – Serious LLM‑assisted coding is far from affordable. The token consumption needed for real‑world code changes blows past the “too cheap to meter” narrative, and the subsidy baked into subscription plans cannot last.
The problem: cost is invisible until you hit the limits
When Claude Max or ChatGPT‑4 Turbo is sold as a $20‑$100 /month plan, the headline numbers look attractive: a few million tokens per month, “unlimited” usage for simple chat, and a claim that inference has become “too cheap to meter.”
For a developer who wants to use an LLM as a coding assistant, the reality is very different. The model must not only read the prompt, it also runs a cascade of hidden steps – generating candidate code, executing it, testing the result, feeding the output back into the model, and repeating until the change compiles. Those internal loops are billed at the output token rate, even though the user never sees them.
Key data point – Opus 4.6 charges $5 / M input tokens and $25 / M output tokens. A single “high‑effort” coding turn can consume 30‑50 K hidden tokens, which translates to roughly $0.75‑$1.25 per turn before any visible output is counted.
How the numbers add up
| Scenario | Tokens (input) | Tokens (output) | API cost |
|---|---|---|---|
| Simple chat (budget model) | 200 | 400 | <$0.01 |
| Small script generation (single file) | 2 K | 4 K | $0.13 |
| Complex multi‑file change (≈40 k LOC) | 1 M (incl. hidden) | 1 M | $25 |
| Full‑day of agentic coding (5‑10 tasks) | 5‑10 M | 5‑10 M | $125‑$250 |
When the author moved from a $20 /month plan to the $100 /month Claude Max tier, the weekly token limit stopped being a bottleneck. However, a single large refactor still burned the equivalent of $20 in API‑rate tokens in under half an hour. Multiply that by a team of engineers working full‑time and the hidden cost quickly eclipses the subscription price.
Subsidy vs. reality
The author measured the effective subsidy factor for a typical coding workflow:
- Tokens used in a month: ~4 M (API‑price value ≈ $450)
- Subscription paid: $180
- Effective subsidy: 2.5×
If the weekly limit is fully utilized (no human‑in‑the‑loop throttling), the subsidy could rise to ≈12× – meaning the provider is effectively paying $12 for every $1 the user spends on the service.
Such a model can only survive while the company is flush with venture capital or until an IPO forces a pricing correction. The recent Opus 4.7 release appears to trim the recursive “thinking” budget, suggesting Anthropic is already tightening the leak.
Why coding is the poster child
Coding is a constrained domain: the compiler will reject most syntactic errors, and unit tests expose logical bugs quickly. This makes it possible to filter out the low‑quality output of a generative model, but only at the expense of many hidden inference cycles. The cost curve therefore looks like this:
The chart (created by Renske Wierda) shows task cost at API pricing. Simple coding stays under $5 per task, while complex multi‑file edits climb past $60.
The steep rise is not a sign of the model becoming smarter; it is the price of brute‑force recursion. As model size grows, the number of internal trial‑and‑error steps grows faster than the per‑token price drops.
Implications for the market
- Start‑ups and small teams – The current subsidy makes LLM‑coding viable only for occasional, high‑impact tasks. Full‑time agentic coding would burn through a $100 /month plan in a few days.
- Enterprises – Large organizations can afford the hidden cost, but they must budget for API‑rate pricing rather than rely on subscription caps. Some are already seeing single‑task bills in the $30‑$35 k range for deep code‑base analysis.
- Investors – The “killer app” narrative rests on the assumption that the hidden cost will stay hidden. Once the subsidy disappears, the revenue model will need to shift to a true usage‑based pricing, which could dramatically shrink the addressable market.
- OpenAI vs. Anthropic – Both providers show similar token economics. OpenAI’s GPT‑4o and upcoming GPT‑5.x pricing lines up with Anthropic’s Opus 4.6‑4.8, meaning the cost pressure is industry‑wide, not a single‑vendor issue.
What to watch next
- Opus 4.8 and beyond – Early reports suggest a reduction in the recursive token budget, which will raise per‑task costs unless the per‑token price drops further.
- Tool‑call pricing – As models rely more on external tools (e.g., code linters, test runners), the cost of those API calls will become a separate line item.
- Hybrid workflows – Teams that combine a cheap budget model for scaffolding with a high‑effort model only for verification may find a sustainable sweet spot.
Bottom line
The promise of “AI builds itself” and “coding is the killer app” is built on a fragile economic foundation. When the subsidy evaporates, the cost per serious coding task will be well over $1,000 for every $100 a user pays in a subscription. Developers should treat LLM‑coding as a productivity aid rather than a wholesale replacement, and plan for the day when the hidden token bill arrives.
Sources: Anthropic pricing page, OpenAI pricing documentation, internal Claude Code usage logs, cost analysis by Faros.ai, Reddit discussion of Opus 4.8, Branch8 cost report.
Comments
Please log in or register to join the discussion