The AI Free Ride Is Over: Why Your Token Bill Is About to Skyrocket

Simon Willison ran a tool to check his actual token usage last week. The result: $2,180 worth of API calls in 30 days. His subscription cost? $200. That's an 11x gap, and it tells you exactly where the AI industry is going.

Over the past two months, both Anthropic and OpenAI have quietly executed the same playbook: shift enterprise customers from flat-rate pricing to per-token billing. The free ride is over, and developers who depend on AI coding agents are about to feel it.

The Pricing Shift Nobody Noticed

Here's what changed and when:

Anthropic (Claude Code, Enterprise plans): Originally sold as "Claude seats include enough usage for a typical workday" at a flat rate. Sometime in the last six months, new enterprise contracts switched to $20 per seat per month plus API token pricing. Existing customers are discovering this change as their contracts come up for renewal. The Information reported on the shift on April 14, but an Anthropic spokesperson claimed the change actually happened in November 2025.

OpenAI (Codex, April 2026): On April 2, OpenAI switched Codex pricing from per-message to per-token billing for Plus, Pro, and ChatGPT Business plans. By April 23, this applied to all Enterprise plans, including Edu, Health, Gov, and ChatGPT for Teachers. The credits system maps directly to API token costs.

In both cases, the flat-rate era is dead. You now pay for every token your developers consume.

How Much Are Developers Actually Using?

Willison's ccusage tool breakdown is revealing:

$ ccusage
Anthropic Claude Code (30 days): $1,199.79
OpenAI Codex (30 days):         $980.37
Total:                          $2,180.16

He describes himself as a "moderately heavy user, certainly not running agents every hour." If a single power user hits $2k per month, imagine a 50-person engineering team.

Let's do the math:

Monthly AI tooling cost for a 50-dev team:
------------------------------------------
Light users (40 devs, ~$200/month):    $8,000
Heavy users (8 devs, ~$800/month):     $6,400
Power users (2 devs, ~$2,000/month):   $4,000
                                       -------
Monthly total:                         $18,400
Annual:                                $220,800

For context, that's roughly the cost of two additional senior engineers. Is the productivity gain worth it? For many teams, absolutely. But the bill still stings when you weren't budgeting for it.

The Hacker News Reaction

Simon Willison's piece hit 765 points and 400+ comments on Hacker News within hours. The top threads reveal three camps of developers:

Camp 1: "This is fine, still worth it"

"I would gladly pay $1k/month for Claude Code. It's replaced 2-3 hours of tedious work every single day." , top-voted comment

Camp 2: "I'm cutting back"

Multiple developers reported setting hard daily token budgets, switching to local models for boilerplate code, and being more selective about when they invoke agents. One developer built a wrapper that routes simple queries to Ollama and only escalates to Claude for complex refactors.

Camp 3: "We're building alternatives"

Several HN commenters shared projects to build cost-aware coding agents that track token usage in real time, display a running tally in the terminal, and cut off requests when they exceed a budget. These tools didn't exist three months ago because nobody needed them.

What This Means for the AI Industry

The pricing shift isn't just about revenue. It signals something bigger: product-market fit.

Simon Willison's title says it plainly: "I think Anthropic and OpenAI have found product-market fit." When customers complain about prices instead of switching off entirely, that's a strong signal. Enterprise users aren't leaving. They're paying.

But there's a second signal: the labs are under immense pressure to become profitable. The Verge's Hayden Field captured it perfectly in April with the headline "You're about to feel the AI money squeeze." The billions in venture funding and compute costs don't pay for themselves.

Anthropic is rumored to be approaching its first profitable quarter. OpenAI, with its massive infrastructure spend, is likely further away. But both are now acting like real businesses, not research labs with infinite runway.

Practical Steps for Developers

If your team relies on AI coding agents, here's what you should do now:

1. Audit your actual usage

Neither Anthropic nor OpenAI makes this easy. Willison built ccusage himself because the platforms don't surface per-user token costs. Until first-party tools arrive, here's a quick audit approach:

# For Claude Code users: check the usage log
cat ~/.claude/usage.json | python3 -c "
import json, sys
data = json.load(sys.stdin)
total_tokens = sum(session.get('tokens', 0) for session in data)
# Rough estimate: $15 per million input tokens, $75 per million output tokens
print(f'Total tokens: {total_tokens:,}')
print(f'Estimated cost: ${total_tokens / 1_000_000 * 45:.2f}')
"

2. Set budgets before you need them

Most teams discover they have a problem when the CFO forwards a $50,000 invoice. Set per-developer or per-team monthly budgets now. If your platform doesn't support hard limits, implement soft limits with monitoring:

# Simple cost tracker for team AI usage
import json
from datetime import datetime
from collections import defaultdict

class AICostTracker:
    def __init__(self, budget_per_dev=500):
        self.budget = budget_per_dev
        self.usage = defaultdict(float)

    def record_usage(self, developer, tokens, model):
        # Approximate pricing (varies by model/provider)
        rates = {
            'claude-sonnet-4': 15,     # per million tokens
            'claude-opus-4': 45,
            'gpt-4o': 10,
            'gpt-4.1': 30,
        }
        rate = rates.get(model, 15)
        cost = (tokens / 1_000_000) * rate
        self.usage[developer] += cost

        if self.usage[developer] > self.budget * 0.8:
            print(f"WARNING: {developer} at {self.usage[developer]:.0%} of budget")

    def report(self):
        for dev, cost in sorted(self.usage.items(), key=lambda x: -x[1]):
            print(f"{dev}: ${cost:.2f} / ${self.budget} budget")

3. Route intelligently

Not every task needs Claude Opus or GPT-4.1. Build a triage system:

Task complexity        Recommended model       Cost per million tokens
------------------     -------------------     -----------------------
Boilerplate, types     Local (Ollama/Llama)    $0
Simple refactors       Claude Haiku / GPT-4o   $1-3
Complex debugging      Claude Sonnet           $15
Architecture design    Claude Opus / GPT-4.1   $45-75

4. Cache aggressively

If five developers ask Claude Code essentially the same question about your codebase, you're paying for that answer five times. A shared context cache or team-level prompt library can cut repeat costs dramatically.

The Bottom Line

The AI industry has crossed a threshold. Two years ago, AI coding tools were a novelty. Six months ago, they were a productivity boost. Today, they're essential infrastructure that costs real money.

The good news: if you're paying $1,000 per month for AI tools that save you 40+ hours of work, your ROI is absurdly positive. A developer's time is worth far more than $25 per hour.

The bad news: nobody told you the meter was running. And if you're not tracking it, you'll find out from accounting.

Simon Willison ended his piece with a telling observation: "I think they've found product-market fit. And they're ramping up." Developer tools that people complain about but keep paying for? That's exactly what product-market fit looks like.

Now go check your token usage. It's probably higher than you think.