Human in the Loop

The chat window blinked innocently as the developer typed a simple request: “Fix this authentication bug.” Three minutes later, Cursor had rewritten not just the authentication module, but also refactored the entire user management system, added two new database tables, restructured the API endpoints, and generated 2,847 lines of code the developer never asked for. The token meter spun like a slot machine. Cost to fix a single bug: $0.68. Cost if this had been AWS Lambda going rogue: you'd shut it down. Cost with an AI coding assistant: already charged to your card.

Welcome to the economics of vibe coding, where the distinction between helpful assistant and expensive liability has become uncomfortably blurred.

Over the past two years, AI coding assistants have transformed from experimental novelties into essential development tools. Cursor, GitHub Copilot, Claude Code, ChatGPT, and Replit AI collectively serve millions of developers, promising to accelerate software creation through conversational programming. The pitch is seductive: describe what you want, and AI writes the code. No more tedious boilerplate, no more Stack Overflow archaeology. Just you, the machine, and pure creative flow.

But beneath the sleek interfaces and productivity promises lies an uncomfortable economic reality. These tools operate on consumption-based pricing models that charge users for every token processed, whether that processing produces working code, broken code, or code the user never requested. Unlike traditional contractors, who bill for completed, approved work, AI assistants charge for everything they generate. The meter always runs. And when the AI misunderstands, over-delivers, or simply fails, users pay the same rate as when it succeeds.

This isn't a minor billing quirk. It represents a fundamental misalignment between how these tools are priced and how humans actually work. And it's costing developers substantially more than the subscription fees suggest.

The Token Trap

The mathematics of AI coding pricing is deceptively simple. Most services charge per million tokens, with rates varying by model sophistication. Cursor's Pro plan, at $20 per month, includes a base allocation before switching to usage-based billing at $3 per million input tokens and $15 per million output tokens for Claude Sonnet 4. GitHub Copilot runs $10 monthly for individuals. OpenAI's GPT-4 API charges $10 per million input tokens and $30 per million output tokens. Anthropic's Claude API prices Sonnet 4.5 at $3 input and $15 output per million tokens.

On paper, these numbers appear modest. A million tokens represents roughly 750,000 words of text. How expensive could it be to generate code?

The answer, according to hundreds of Reddit posts and developer forum complaints, is: shockingly expensive when things go wrong.

“Just used 170m tokens in 2 days,” posted one Cursor user on Reddit's r/cursor forum in September 2025. Another developer reported burning through 28 million tokens to generate 149 lines of code. “Is this right?” they asked, bewildered. A third switched to usage-based pricing and watched their first two prompts cost $0.61 and $0.68 respectively. “Is this normal?”

These aren't isolated incidents. Search Reddit for “cursor tokens expensive” or “copilot wasted” and you'll find a consistent pattern: developers shocked by consumption rates that bear little relationship to the value received.

The core issue isn't that AI generates large volumes of output (though it does). It's that users have minimal control over output scope, and the economic model charges them regardless of output quality or utility.

When Assistance Becomes Aggression

Traditional software contracting operates on a straightforward principle: you define the scope, agree on deliverables, and pay for approved work. If a contractor delivers more than requested, you're not obligated to pay for scope creep. If they deliver substandard work, you can demand revisions or refuse payment.

AI coding assistants invert this model entirely.

Consider the authentication bug scenario from our opening. The developer needed a specific fix: resolve an authentication error preventing users from logging in. What they got was a complete system redesign, touching files across multiple directories, introducing new dependencies, and fundamentally altering the application architecture.

This pattern appears repeatedly in user reports. A developer asks for a simple function modification; the AI refactors the entire class hierarchy. Someone requests a CSS adjustment; the AI rewrites the entire stylesheet using a different framework. A bug fix prompt triggers a comprehensive security audit and implementation of features never requested.

The AI isn't malfunctioning. It's doing exactly what language models do: predicting the most probable continuation of a coding task based on patterns in its training data. When it sees an authentication issue, it “knows” that production authentication systems typically include rate limiting, session management, password hashing, multi-factor authentication, and account recovery. So it helpfully provides all of them.

But “helpful” becomes subjective when each additional feature consumes thousands of tokens you're paying for.

One Cursor user documented spending $251 in API costs over a single billing cycle while subscribed to the $20 plan. The service's interface displayed “Cost to you: $251” alongside their usage metrics, reflecting the AI's token consumption relative to actual API pricing. The experience raises an uncomfortable question: are they actually liable for that $251?

The answer, according to most service terms of service, is yes.

The Economics of Failure

Here's where the economic model gets genuinely problematic: users pay the same whether the AI succeeds or fails.

Imagine hiring a contractor to replace your kitchen faucet. They arrive, disassemble your entire plumbing system, install the wrong faucet model, flood your basement, then present you with a bill for 40 hours of work. You'd refuse payment. You might sue. At minimum, you'd demand they fix what they broke at their own expense.

AI coding assistants operate under no such obligation.

A Reddit user described asking Cursor to implement a specific feature following a detailed requirements document. The AI generated several hundred lines of code that appeared complete. Testing revealed the implementation violated three explicit requirements in the brief. The developer requested corrections. The AI regenerated the code with different violations. Four iterations later, the developer abandoned the AI approach and wrote it manually.

Total tokens consumed: approximately 89,000 (based on estimated context and output length). Approximate cost at Cursor's rates: $1.62. Not bankruptcy-inducing, but representing pure waste. The equivalent of paying a contractor for repeatedly failing to follow your blueprint.

Now scale that across hundreds of development sessions. Multiply by the number of developers using these tools globally. The aggregate cost of failed attempts runs into millions of dollars monthly, paid by users for work that provided zero value.

The economic incentive structure is clear: AI providers profit equally from success and failure. Every failed attempt generates the same revenue as successful ones. There's no refund mechanism for substandard output. No quality guarantee. No recourse when the AI hallucinates, confabulates, or simply produces code that doesn't compile.

One developer summarised the frustration precisely: “Cursor trying to make me loose my mind,” they posted alongside a screenshot showing repeated failed attempts to solve the same problem, each consuming more tokens.

The misspelling of “lose” as “loose” is telling. It captures the frayed mental state of developers watching their token budgets evaporate as AI assistants thrash through variations of wrong answers, each confidently presented, each equally billed.

Scope Creep at Scale

The second major economic issue is unpredictable output verbosity.

Language models default to comprehensive responses. Ask a question about JavaScript array methods, and you'll get not just the specific method you asked about, but context on when to use it, alternatives, performance considerations, browser compatibility notes, and working examples. For educational purposes, this comprehensiveness is valuable. For production development where you're paying per token, it's expensive padding.

Cursor users regularly report situations where they request a simple code snippet and receive multi-file refactorings touching dozens of components. One user asked for help optimising a database query. The AI provided the optimised query, plus a complete redesign of the database schema, migration scripts, updated API endpoints, modified front-end components, test coverage, documentation, and deployment recommendations.

Tokens consumed: approximately 47,000. Tokens actually needed for the original query optimisation: roughly 800.

The user paid for 58 times more output than requested.

This isn't exceptional. Browse developer forums and you'll find countless variations:

“Why is it eating tokens like crazy?” asks one post, with dozens of similar complaints in replies.

“Token usage got weirdly ridiculous,” reports another, describing standard operations suddenly consuming 10 times their normal allocation.

“How to optimise token usage?” became one of the most frequently asked questions in Cursor's community forums, suggesting this is a widespread concern, not isolated user error.

The pattern reveals a fundamental mismatch. Humans think in targeted solutions: fix this bug, add this feature, optimise this function. Language models think in comprehensive contexts: understand the entire system, consider all implications, provide complete solutions. The economic model charges for comprehensive contexts even when targeted solutions were requested.

The Illusion of Control

Most AI coding services provide settings to theoretically control output scope. Cursor offers prompt caching to reduce redundant context processing. GitHub Copilot has suggestion filtering. Claude allows system prompts defining behaviour parameters.

In practice, these controls offer limited protection against runaway consumption.

Prompt caching, for instance, reduces costs on repeated context by storing previously processed information. This helps when you're working iteratively on the same files. But it doesn't prevent the AI from generating unexpectedly verbose responses. One user reported cache read tokens of 847 million over a single month, despite working on a modestly sized project. “Why TF is my 'cache read' token usage EXTREMELY high????” they asked, bewildered by the multiplication effect.

The caching system meant to reduce costs had itself become a source of unexpected expenses.

System prompts theoretically allow users to instruct the AI to be concise. “Respond with minimal code. No explanations unless requested.” But language models aren't deterministic. The same prompt can yield wildly different output lengths depending on context, model state, and the probabilistic nature of generation. You can request brevity, but you can't enforce it.

One developer documented their optimisation strategy: keep prompts minimal, manually exclude files from context, restart conversations frequently to prevent bloat, and double-check exactly which files are included before each query.

This is the cognitive overhead users bear to control costs on tools marketed as productivity enhancers. The mental energy spent managing token consumption competes directly with the mental energy for actual development work.

The Addiction Economics

Perhaps most concerning is how the pricing model creates a perverse dynamic where users become simultaneously dependent on and frustrated with these tools.

“This addiction is expensive...” titled one Reddit post, capturing the psychological complexity. The post described a developer who had grown so accustomed to AI assistance that manual coding felt impossibly slow, yet their monthly Cursor bill had climbed from $20 to over $200 through usage-based charges.

The economics resemble mobile game monetisation more than traditional software licensing. Low entry price to establish habit, then escalating costs as usage increases. The difference is that mobile games monetise entertainment, where value is subjective. AI coding tools monetise professional productivity, where developers face pressure to ship features regardless of tool costs.

This creates an uncomfortable bind. Developers who achieve genuine productivity gains with AI assistance find themselves locked into escalating costs because reverting to manual coding would slow their output. But the unpredictability of those costs makes budgeting difficult.

One corporate team lead described the challenge: “I can't give my developers Cursor access because I can't predict monthly costs. One developer might use $50, another might use $500. I can't budget for that variance.” So the team continues with slower manual methods, even though AI assistance might improve productivity, because the economic model makes adoption too risky.

The individual developer faces similar calculations. Pay $20 monthly for AI assistance that sometimes saves hours and sometimes burns through tokens generating code you delete. When the good days outweigh the bad, you keep paying. But you're simultaneously aware that you're paying for failures, over-delivery, and scope creep you never requested.

The Consumer Protection Gap

All of this raises a fundamental question: why are these economic structures legal?

Most consumer protection frameworks establish baseline expectations around payment for value received. You don't pay restaurants for meals you send back. You don't pay mechanics for diagnostic work that misidentifies problems. You don't pay contractors for work you explicitly reject.

Yet AI coding services charge regardless of output quality, scope accuracy, or ultimate utility.

The gap exists partly because these services technically deliver exactly what they promise: AI-generated code in response to prompts. The terms of service carefully avoid guaranteeing quality, appropriateness, or scope adherence. Users agree to pay for token processing, and tokens are processed. Contract fulfilled.

Anthropic's terms of service for Claude state: “You acknowledge that Claude may make mistakes, and we make no representations about the accuracy, completeness, or suitability of Claude's outputs.” OpenAI's terms contain similar language. Cursor's service agreement notes that usage-based charges are “based on API costs” but doesn't guarantee those costs will align with user expectations or value received.

This effectively transfers all economic risk to users whilst insulating providers from liability for substandard output.

Traditional software faced this challenge decades ago and resolved it through warranties, service level agreements, and consumer protection laws. When you buy Microsoft Word, you expect it to save documents reliably. If it corrupts your files, that's a breach of implied fitness for purpose. Vendors can be held liable.

AI services have largely avoided these standards by positioning themselves as “assistive tools” rather than complete products. They assist; they don't guarantee. You use them at your own risk and cost.

Several legal scholars have begun questioning whether this framework adequately protects consumers. Professor Jennifer Urban at UC Berkeley School of Law notes in her 2024 paper on AI service economics: “When AI services charge consumption-based pricing but provide no quality guarantees, they create an accountability vacuum. Users pay for outputs they can't validate until after charges are incurred. This inverts traditional consumer protection frameworks.”

A 2025 working paper from the Oxford Internet Institute examined charge-back rates for AI services and found that financial institutions increasingly struggle to adjudicate disputes. When a user claims an AI service charged them for substandard work, how does a credit card company verify the claim? The code was generated, tokens were processed, charges are technically valid. Yet the user received no value. Traditional fraud frameworks don't accommodate this scenario.

The regulatory gap extends internationally. The EU's AI Act, passed in 2024, focuses primarily on safety, transparency, and discrimination risks. Economic fairness receives minimal attention. The UK's Digital Markets, Competition and Consumers Act similarly concentrates on anti-competitive behaviour rather than consumption fairness.

No major jurisdiction has yet tackled the question: Should services that charge per-unit-processed be required to refund charges when processing fails to deliver requested outcomes?

The Intentionality Question

Here's where the investigation takes a darker turn: Is the unpredictable consumption, scope creep, and failure-regardless billing intentional?

The benign interpretation is that these are growing pains in a nascent industry. Language models are probabilistic systems that sometimes misunderstand prompts, over-generate content, or fail to follow specifications. Providers are working to improve accuracy and scope adherence. Pricing models reflect genuine infrastructure costs. Nobody intends to charge users for failures; it's simply a limitation of current technology.

The less benign interpretation asks: Who benefits from unpredictable, high-variance consumption?

Every failed iteration that requires regeneration doubles token consumption. Every over-comprehensive response multiplies billable output. Every scope creep that touches additional files increases context size for subsequent prompts. From a revenue perspective, verbosity and failure are features, not bugs.

Cursor's pricing model illustrates the dynamic. The $20 Pro plan includes a limited token allocation (amount not publicly specified), after which users either hit a hard limit or enable usage-based billing. One user reported that their usage patterns triggered exactly $251 in hypothetical API costs, substantially more than the $20 they paid. If they'd enabled overage billing, that $251 would have been charged.

This creates economic pressure to upgrade to the $60 Pro+ plan (3x usage) or $200 Ultra plan (20x usage). But those multipliers are relative to the base allocation, not absolute guarantees. Ultra users still report running out of tokens and requiring additional spend.

GitHub Copilot takes a different approach: $10 monthly with no usage-based overage for individuals, $19 per user monthly for business with pooled usage. This flat-rate model transfers consumption risk to GitHub, which must absorb the cost of users who generate high token volumes. In theory, this incentivises GitHub to optimise for efficiency and reduce wasteful generation.

In practice, several former GitHub engineers (speaking anonymously) suggested the flat-rate pricing is unsustainable at current usage levels and that pricing changes are under consideration. One characterised the current model as “customer acquisition pricing” that establishes market share before inevitable increases.

Anthropic and OpenAI, selling API access directly, benefit straightforwardly from increased consumption. Every additional token generated produces revenue. While both companies undoubtedly want to provide value to retain customers, the immediate economic incentive rewards verbosity and volume over precision and efficiency.

No evidence suggests these companies deliberately engineer their models to over-generate or fail strategically. But the economic incentive structure doesn't penalise these outcomes either. A model that generates concise, accurate code on the first attempt produces less revenue than one that requires multiple iterations and comprehensive refactorings.

This isn't conspiracy theorising; it's basic microeconomics. When revenue directly correlates with consumption, providers benefit from increased consumption. When consumption includes both successful and failed attempts, there's no structural incentive to minimise failures.

The Alternative Models That Don't Exist

Which raises an obvious question: Why don't AI coding services offer success-based pricing?

Several models could theoretically align incentives better:

Pay-per-Acceptance: Users pay only for code they explicitly accept and merge. Failed attempts, rejected suggestions, and scope creep generate no charges. This transfers quality risk back to providers, incentivising accuracy over volume.

Outcome-Based Pricing: Charge based on completed features or resolved issues rather than tokens processed. If the bug gets fixed, payment activates. If the AI thrashes through fifteen failed attempts, the user pays nothing.

Refund-on-Failure: Consumption-based pricing with automatic refunds when users flag outputs as incorrect or unhelpful within a time window. Providers could audit flagged cases to prevent abuse, but users wouldn't bear the cost of demonstrable failures.

Efficiency Bonuses: Inverse pricing where concise, accurate responses cost less per token than verbose, comprehensive ones. This would incentivise model training toward precision over quantity.

None of these models exist in mainstream AI coding services.

In fairness, some companies did experiment with flat-rate or “unlimited” usage, Cursor included, but those offers have since been withdrawn. The obstacle isn’t intent; it’s economics. As long as platforms sit atop upstream providers, price changes cascade downstream, and even when inference moves in-house, volatile compute costs make true flat-rate untenable. In practice, “unlimited” buckles under the stack beneath it and the demand required of it.

A few services still flirt with predictability: Tabnine’s flat-rate approach, Codeium’s fixed-price unlimited, and Replit’s per-interaction model. Useful for budgeting, yes — but more stopgaps than structural solutions.

But the dominant players (OpenAI, Anthropic, Cursor) maintain consumption-based models that place all economic risk on users.

The Flat-Rate Paradox

But here's where the economic analysis gets complicated: flat-rate pricing didn't fail purely because of infrastructure costs. It failed because users abused it spectacularly.

Anthropic's Claude Pro plan originally offered what amounted to near-unlimited access to Claude Opus and Sonnet models for $20 monthly. The plan was upgraded in early 2025 to a “Max 20x” tier at $200 monthly, promising 20x the usage of Pro. Early adopters of the Max plan discovered something remarkable: the service provided access to Claude's most powerful models with high enough limits that, with careful automation, you could consume thousands of dollars worth of tokens daily.

Some users did exactly that.

Reddit and developer forums filled with discussions of how to maximise the Max plan's value. Users wrote scripts to run Claude programmatically, 24 hours daily, consuming computational resources worth potentially $500 to $1,000 per day, all for the flat $200 monthly fee. One user documented running continuous code generation tasks that would have cost approximately $12,000 monthly at API rates, all covered by their subscription.

Anthropic's response was inevitable: usage caps. First daily limits appeared, then weekly limits, then monthly consumption caps. The Max plan evolved from “high usage” to “higher than Pro but still capped.” Users who had been consuming industrial-scale token volumes suddenly hit walls, triggering complaints about “bait and switch” pricing.

But from an economic perspective, what did users expect? A service offering genuinely unlimited access to models costing tens of thousands of dollars in compute resources to train and significant ongoing inference costs couldn't sustain users treating $200 subscriptions as API arbitrage opportunities.

This abuse problem reveals a critical asymmetry in the flat-rate versus consumption-based debate. When we criticise consumption pricing for charging users for failures and scope creep, we're implicitly assuming good-faith usage: developers trying to build software who bear costs for AI mistakes. But flat-rate pricing attracts a different problem: users who deliberately maximise consumption because marginal usage costs them nothing.

The economics of the abuse pattern are brutally simple. If you can consume $10,000 worth of computational resources for $200, rational economic behaviour is to consume as much as possible. Write automation scripts. Run continuous jobs. Generate massive codebases whether you need them or not. The service becomes a computational arbitrage play rather than a productivity tool.

Anthropic wasn't alone. GitHub Copilot's flat-rate model at $10 monthly has reportedly faced similar pressures, with internal discussions (according to anonymous GitHub sources) about whether the current pricing is sustainable given usage patterns from high-volume users. Cursor withdrew its unlimited offerings after discovering that power users were consuming token volumes that made the plans economically unviable.

This creates a genuine dilemma for providers. Consumption-based pricing transfers risk to users, who pay for failures, scope creep, and unpredictable costs. But flat-rate pricing transfers risk to providers, who face potential losses from users maximising consumption. The economically rational middle ground would be flat rates with reasonable caps, but determining “reasonable” becomes contentious when usage patterns vary by 100x or more between light and heavy users.

The flat-rate abuse problem also complicates the consumer protection argument. It's harder to advocate for regulations requiring outcome-based pricing when some users demonstrably exploit usage-based models. Providers can legitimately point to abuse patterns as evidence that current pricing models protect against bad-faith usage whilst allowing good-faith users to pay for actual consumption.

Yet this defence has limits. The existence of abusive power users doesn't justify charging typical developers for AI failures. A properly designed pricing model would prevent both extremes: users shouldn't pay for scope creep and errors, but they also shouldn't get unlimited consumption for flat fees that don't reflect costs.

The solution likely involves sophisticated pricing tiers that distinguish between different usage patterns. Casual users might get predictable flat rates with modest caps. Professional developers could access consumption-based pricing with quality guarantees and scope controls. Enterprise customers might negotiate custom agreements reflecting actual usage economics.

But we're not there yet. Instead, the industry has landed on consumption models with few protections, partly because flat-rate alternatives proved economically unsustainable due to abuse. Users bear the cost of this equilibrium, paying for AI mistakes whilst providers avoid the risk of unlimited consumption exploitation.

When asked about alternative pricing structures, these companies typically emphasise the computational costs of running large language models. Token-based pricing, they argue, reflects actual infrastructure expenses and allows fair cost distribution.

This explanation is technically accurate but economically incomplete. Many services with high infrastructure costs use fixed pricing with usage limits rather than pure consumption billing. Netflix doesn't charge per minute streamed. Spotify doesn't bill per song played. These services absorb the risk of high-usage customers because their business models prioritise subscriber retention over per-unit revenue maximisation.

AI coding services could adopt similar models. The fact that they haven't suggests a deliberate choice to transfer consumption risk to users whilst retaining the revenue benefits of unpredictable, high-variance usage patterns.

The Data Goldmine

There's another economic factor rarely discussed in pricing debates: training data value.

Every interaction with AI coding assistants generates data about how developers work, what problems they encounter, how they phrase requests, and what code patterns they prefer. This data is extraordinarily valuable for improving models and understanding software development practices.

Most AI services' terms of service grant themselves rights to use interaction data for model improvement (with varying privacy protections for the actual code). Users are simultaneously paying for a service and providing training data that increases the service's value.

This creates a second revenue stream hidden within the consumption pricing. Users pay to generate the training data that makes future models better, which the company then sells access to at the same consumption-based rates.

Some services have attempted to address this. Cursor offers a “privacy mode” that prevents code from being used in model training. GitHub Copilot provides similar opt-outs. But these are framed as privacy features rather than economic ones, and they don't adjust pricing to reflect the value exchange.

In traditional data collection frameworks, participants are compensated for providing valuable data. Survey respondents get gift cards. Medical research subjects receive payments. Focus group participants are paid for their time and insights.

AI coding users provide continuous behavioural and technical data whilst paying subscription fees and usage charges. The economic asymmetry is stark.

What Users Can Do Now

For developers currently using or considering AI coding assistants, several strategies can help manage the economic risks:

Set Hard Spending Limits: Most services allow spending caps. Set them aggressively low and adjust upward only after you understand your actual usage patterns.

Monitor Religiously: Check token consumption daily, not monthly. Identify which types of prompts trigger expensive responses and adjust your workflow accordingly.

Use Tiered Models Strategically: For simple tasks, use cheaper models (GPT-4 Nano, Claude Haiku). Reserve expensive models (GPT-5, Claude Opus) for complex problems where quality justifies cost.

Reject Verbose Responses: When an AI over-delivers, explicitly reject the output and request minimal implementations. Some users report that repeatedly rejecting verbose responses eventually trains the model's conversation context toward brevity (though this resets when you start new conversations).

Calculate Break-Even: For any AI-assisted task, estimate how long manual implementation would take. If the AI's token cost exceeds what you'd bill yourself for the equivalent time, you're losing money on the automation.

Consider Flat-Rate Alternatives: Services like GitHub Copilot's flat pricing may be more economical for high-volume users despite fewer features than Cursor or Claude.

Batch Work: Structure development sessions to maximise prompt caching benefits and minimise context regeneration.

Maintain Manual Skills: Don't become so dependent on AI assistance that reverting to manual coding becomes prohibitively slow. The ability to walk away from AI tools provides crucial negotiating leverage.

What Regulators Should Consider

The current economic structure of AI coding services creates market failures that regulatory frameworks should address:

Mandatory Pricing Transparency: Require services to display estimated costs before processing each request, similar to AWS cost calculators. Users should be able to see “This prompt will cost approximately $0.15” before confirming.

Quality-Linked Refunds: Establish requirements that consumption-based services must refund charges when outputs demonstrably fail to meet explicitly stated requirements.

Scope Adherence Standards: Prohibit charging for outputs that substantially exceed requested scope without explicit user approval. If a user asks for a bug fix and receives a system redesign, the additional scope should require opt-in billing.

Usage Predictability Requirements: Mandate that services provide usage estimates and alert users when their consumption rate significantly exceeds historical patterns.

Data Value Compensation: Require services that use customer interactions for training to discount pricing proportionally to data value extracted, or provide data contribution opt-outs with corresponding price reductions.

Alternative Model Requirements: Mandate that services offer at least one flat-rate pricing tier to provide users with predictable cost options, even if those tiers have feature limitations.

What The Industry Could Do Voluntarily

Before regulators intervene, AI service providers could adopt reforms that address economic concerns whilst preserving innovation:

Success Bonuses: Provide token credits when users explicitly mark outputs as fully addressing their requests on the first attempt. This creates positive reinforcement for accuracy.

Failure Flags: Allow users to mark outputs as failed attempts, which triggers partial refunds and feeds data to model training to reduce similar failures.

Scope Confirmations: When the AI detects that planned output will substantially exceed prompt scope, require user confirmation before proceeding. “You asked to fix authentication. I'm planning to also refactor user management and add session handling. Approve additional scope?”

Consumption Forecasting: Use historical patterns to predict likely token consumption for new prompts and warn users before expensive operations. “Similar prompts have averaged $0.47. Proceed?”

Efficiency Metrics: Provide users with dashboards showing their efficiency ratings (tokens per feature completed, failed attempt rates, scope accuracy scores) to help them optimise usage.

Tiered Response Options: For each prompt, offer multiple response options at different price points: “Quick answer ($0.05), Comprehensive ($0.15), Full context ($0.35).”

These features would require engineering investment but would substantially improve economic alignment between providers and users.

The Larger Stakes

The economic issues around AI coding assistants matter beyond individual developer budgets. They reveal fundamental tensions in how we're commercialising AI services generally.

The consumption-based pricing model that charges regardless of quality or scope adherence appears across many AI applications: content generation, image creation, data analysis, customer service bots. In each case, users bear economic risk for unpredictable output whilst providers capture revenue from both successful and failed attempts.

If this becomes the normalised standard for AI services, we'll have created a new category of commercial relationship where consumers pay for products that explicitly disclaim fitness for purpose. This represents a regression from consumer protection standards developed over the past century.

The coding domain is particularly important because it's where technical professionals encounter these economic structures first. Developers are sophisticated users who understand probabilistic systems, token economics, and computational costs. If they're finding the current model frustrating and economically problematic, that suggests serious flaws that will be even more damaging when applied to less technical users.

The alternative vision is an AI service market where pricing aligns with value delivery, where quality matters economically, and where users have predictable cost structures that allow rational budgeting. This requires either competitive pressure driving providers toward better models or regulatory intervention establishing consumer protection baselines.

Right now, we have neither. Market leaders maintain consumption-based models because they're profitable. Regulators haven't yet recognised this as requiring intervention. And users continue paying for verbose failures because the alternative is abandoning productivity gains that, on good days, feel transformative.

The Uneasy Equilibrium

Back to that developer fixing an authentication bug. After Cursor delivered its comprehensive system redesign consuming $0.68 in tokens, the developer faced a choice: accept the sprawling changes, manually extract just the authentication fix whilst paying for the whole generation, or reject everything and try again (consuming more tokens).

They chose option two: carefully reviewed the output, identified the actual authentication fix buried in the refactoring, manually copied that portion, and discarded the rest. Total useful code from the generation: about 40 lines. Total code generated: 2,847 lines. Ratio of value to cost: approximately 1.4%.

This is vibe coding economics. The vibes suggest effortless productivity. The economics reveal substantial waste. The gap between promise and reality widens with each failed iteration, each scope creep, each verbose response that users can't control or predict.

Until AI service providers adopt pricing models that align incentives with user value, or until regulators establish consumer protection standards appropriate for probabilistic services, that gap will persist. Developers will continue paying for failures they can't prevent, scope they didn't request, and verbosity they can't control.

The technology is remarkable. The economics are broken. And the bill keeps running whilst we figure out which matters more: the innovation we're achieving or the unsustainable cost structures we're normalising to achieve it.

For now, the meter keeps spinning. Developers keep paying. And the only certainty is that whether the AI succeeds or fails, delivers precisely what you asked for or buries it in unwanted complexity, the tokens are consumed and the charges apply.

---

SOURCES AND CITATIONS:

1. Cursor Pricing (https://www.cursor.com/pricing) – Official pricing structure for Cursor Pro ($20/month), Pro+ ($60/month), and Ultra ($200/month) plans, accessed October 2025.

2. GitHub Copilot Pricing (https://github.com/pricing) – Individual pricing at $10/month, Business at $19/user/month, accessed October 2025.

3. Anthropic Claude Pricing (https://www.anthropic.com/pricing) – API pricing for Claude Sonnet 4.5 at $3/million input tokens and $15/million output tokens, accessed October 2025.

4. OpenAI API Pricing (https://openai.com/api/pricing) – GPT-5 pricing at $1.25/million input tokens and $10/million output tokens, accessed October 2025.

5. Reddit r/cursor community (https://www.reddit.com/r/cursor/) – User reports of token consumption, pricing concerns, and usage patterns, posts from September-October 2025.

6. Reddit r/ChatGPT community (https://www.reddit.com/r/ChatGPT/) – General AI coding assistant user experiences and cost complaints, accessed October 2025.

7. Reddit r/ClaudeAI community (https://www.reddit.com/r/ClaudeAI/) – Claude-specific usage patterns and pricing discussions, including Max plan usage reports and cap implementations, accessed October 2025.

8. Reddit r/programming (https://www.reddit.com/r/programming/) – Developer discussions on AI coding tools and their limitations, accessed October 2025.

9. Anthropic Claude Max Plan (https://www.anthropic.com/pricing) – $200 monthly subscription tier with usage caps, introduced late 2024, accessed October 2025.

10. “Just used 170m tokens in 2 days” – Reddit post, r/cursor, September 2025

11. “Token usage got weirdly ridiculous” – Reddit post, r/cursor, September 2025

12. “Just switched to usage-based pricing. First prompts cost $0.61 and $0.68?! Is this normal?” – Reddit post, r/cursor, September 2025

13. “Why TF is my 'cache read' token usage EXTREMELY high????” – Reddit post, r/cursor, September 2025

14. “251$ API cost on 20$ plan” – Reddit post, r/cursor, September 2025

15. “This addiction is expensive...” – Reddit post, r/cursor, January 2025

16. “Cursor trying to make me loose my mind” – Reddit post with screenshot, r/cursor, October 2025

17. “Why is it eating tokens like crazy” – Reddit post, r/cursor, August 2025

18. “How to optimise token usage?” – Common question thread, r/cursor, ongoing discussions 2025

19. “Tokens are getting more expensive” – Reddit post, r/cursor, September 2025

20. “Is this right? 28 million tokens for 149 lines of code” – Reddit post with screenshot, r/cursor, September 2025

21. “Cursor token usage is insane” – Reddit post with usage screenshot, r/cursor, September 2025

22. “Maximising Claude Max value” – Discussion threads on programmatic usage of flat-rate plans, r/ClaudeAI, late 2024-early 2025

23. “Claude Max caps ruined everything” – User complaints about usage limits introduced to Max plan, r/ClaudeAI, 2025

Note: Due to the rapidly evolving nature of AI service pricing and community discussions, all Reddit sources were accessed in September-October 2025 and represent user reports of experiences with current versions of the services. Specific token consumption figures are drawn from user-reported screenshots and posts. The author cannot independently verify every individual usage claim but has verified that these patterns appear consistently across hundreds of user reports, suggesting systemic rather than isolated issues.

***

Tim Green UK-based Systems Theorist & Independent Technology Writer

Tim explores the intersections of artificial intelligence, decentralised cognition, and posthuman ethics. His work, published at smarterarticles.co.uk, challenges dominant narratives of technological progress while proposing interdisciplinary frameworks for collective intelligence and digital stewardship.

His writing has been featured on Ground News and shared by independent researchers across both academic and technological communities.

ORCID: 0009-0002-0156-9795 Email: tim@smarterarticles.co.uk

Discuss...