What If AI Was Free Tomorrow, at Exactly Today's Capabilities?

Earlier this week we ran the trendline: token prices collapsing at the floor, five scenarios for where that goes. The fair criticism of any trendline piece is that it smuggles in capability growth - "and then the models get better" is doing half the work. So here is the cleaner experiment, with the sci-fi surgically removed.

The setup: tomorrow morning, every model that exists today costs exactly zero. Nothing gets smarter. Fable 5 stays Fable 5, with its current failure modes. Context windows stay their current sizes. Latency stays. Rate limits vanish, invoices vanish, capability freezes. What actually changes for a working developer by Friday?

We think the answer is: less than the hype says, more than the skeptics say, and mostly in a place neither group is looking at.

The ground rules#

Three things stay scarce at price zero, and the whole experiment turns on them:

1. Wall-clock time. Free tokens are not instant tokens. An agent run that takes 20 minutes still takes 20 minutes; a thousand of them in parallel still need orchestration you have to build.
2. Your attention. Every artifact a model produces either gets reviewed by someone or trusted by someone. Zero price does not mint a single extra reviewer-hour.
3. Correctness. Today's models at today's capability still confidently produce wrong code, wrong claims, wrong fixes at today's rates. Free wrongness is cheaper to generate and exactly as expensive to ship.

Hold those, and the experiment gets interesting.

Day one: everything you already ration becomes unlimited#

Be honest about what you currently do to a model bill. You pick the cheap model for the long task. You keep the agent on a short leash because a runaway loop costs real money at 3am. You run one attempt at the fix, not five. You skip the "eh, probably fine" verification pass because it doubles the tokens.

All of that rationing dies overnight, and the practical playbook is boring in the best way:

• Best-of-N becomes the default for everything. Five candidate implementations per ticket, judged, is strictly better than one when attempts are free. We already argued the judge-over-worker economics; at price zero the ratio goes vertical - use the strongest model that exists for every single judgment call, because why would you not.
• Every repo runs the full always-on fleet. The cron-agent pattern stops being a cost-benefit decision and becomes hygiene, like version control. Doc drift, dependency bumps, flake hunting, refresh loops - all of it, hourly, on everything you own, including the abandoned side projects.
• Verification stops being skipped. Re-verify every claim, re-run every eval matrix, judge every output three ways from three angles. The quality delta between "one pass" and "generate, critique, revise, judge" pipelines is real at current capability - most people skip it because it multiplies cost. That excuse is gone.

Notice what did NOT happen in any of these: nothing got built that today's models cannot build. The gains all come from removing the rationing, and the honest surprise is how much rationing you were doing.

Day two: the bottleneck teleports#

Here is the part we find genuinely interesting. Within about 48 hours of AI being free, nobody's problem is AI anymore. The constraint moves, all at once, to the same place it moved for us when we started running a fleet against this site: review.

Free generation means your PR queue is now effectively infinite. Your issue tracker fills with plausible, sourced, well-formatted proposals faster than any human team can adjudicate them. Every one of those best-of-five candidates needs a judgment, and while model judges are free too, at current capability a model judge is a filter, not a decider - it removes the obviously bad, and the final "yes, ship it" still lands on a person whose day still has 24 hours.

So the real day-two scramble is not "how do we use all this free AI." It is:

• Which decisions can we make mechanical? Every rule you can write down (style, test coverage, API stability, security posture) is a decision a free judge can enforce infinitely. Every taste call you cannot write down is now your scarcest resource.
• What is our actual definition of correct? Teams with strong test suites and evals absorb free generation like a gift. Teams that verify by vibes drown in it. At price zero, the test suite IS the moat - we would bet on the boring team with the great harness over the brilliant team without one, every time.
• Who reviews the reviewers? You will trust model judgment somewhere, because you have to. Choosing where - which lanes auto-merge on a judge's pass and which wait for a human - becomes the most consequential engineering-management decision in the building. We run exactly this split in production today (content auto-merges through layered judges, code waits for a human), and price zero would not change the shape of it at all. It would only raise the volume flowing through it.

What quietly dies#

A few things stop making sense the same morning, at today's capabilities, no improvement required:

• Per-request pricing for AI features. Every "AI-powered" SaaS feature that marks up tokens is instantly a commodity. What survives is whatever surrounds the model call: the data, the workflow, the integration, the trust.
• The cheap-model market. The entire budget tier exists as a price hedge. At zero, everyone uses the strongest model for everything, and the 178x floor-to-frontier spread we tracked this week collapses to a latency question. (This is also the tell that the experiment is fiction: the spread exists because serving frontier models burns real electricity. Someone pays. But it is clarifying to see which market segments only exist because of the meter.)
• "We can't afford to try it." Every speculative refactor, every "what if we rewrote this in X," every migration you deferred because exploration was expensive - the exploration cost is now zero. The decision cost is not, which brings us to the uncomfortable bit.

What does not change at all#

At current capabilities, free does not buy you: correct architecture decisions for your specific context, knowing what your users actually need, the judgment to say no to a plausible-looking feature, incident response you can trust (the oncall gap is a capability gap, not a price gap), or a single additional hour of the senior engineer whose taste the whole operation quietly runs on.

That last one is the punchline of the whole experiment. Price zero makes intelligence-shaped output abundant. It makes judgment exactly as scarce as it was on Thursday. Every consequence above is that one sentence wearing different clothes.

The kicker: you can run this experiment today#

Here is why this is not idle: at the current floor, the experiment is nearly live already. DeepSeek V4 Flash at $0.14/$0.28 per million tokens, Luna at $0.20 after an 80% cut - a heavy day of background-agent work at the floor costs less than a coffee. For maintenance-class work, "AI is free at current capabilities" is not a thought experiment. It is a rounding error you are treating as a budget line.

Which means the day-two problems are available to you right now, ahead of everyone who is still optimizing their token spend: make your definition of correct executable, decide which lanes get to auto-merge, build the review pipeline that absorbs abundance instead of drowning in it. The teams that do that now are pre-adapted for every further price cut. The ones that do not will discover, one cut at a time, that the meter was never the thing protecting them.

The falsifiable version of our bet, so we can grade ourselves later: within 18 months, "review capacity" and "eval coverage" appear as first-class line items in mainstream engineering-planning tools, the way "CI minutes" did. If free-adjacent AI does not force that within 18 months, we were wrong about where the bottleneck lands, and we will write that piece too.

FAQ#

Is this scenario realistic?#

The literal version, no - frontier inference burns real compute and someone pays for it. But the floor tier is close enough to free for maintenance-class work today that the experiment's conclusions apply now, not hypothetically.

What should a developer actually do differently based on this?#

Stop rationing the cheap tier: run best-of-N with a judge on real tasks, put background agents on your repos, and spend the saved effort making your tests and evals strong enough to absorb the extra output. The bottleneck is review, so invest there first.

Does free AI at current capabilities replace developers?#

No - it replaces the rationing of AI output. At today's capability, every additional unit of output creates a review obligation, so human judgment becomes more binding, not less. What changes is the job's center of gravity: from producing artifacts to specifying and judging them.

What would prove this analysis wrong?#

If generation stays the bottleneck as prices fall - that is, if teams with unlimited cheap tokens ship no faster because model capability, not review capacity, was the real constraint all along. Watchable within 18 months.

Sources#

Last updated: July 31, 2026

Continue Reading#

• What Happens When Tokens Are Too Cheap to Meter - the trendline version this experiment stress-tests
• Put an AI Agent on a Cron Job - the always-on pattern that becomes hygiene at price zero
• Agent Fleet Economics - worker/judge splits, the architecture this experiment vindicates
• Fable 5 vs DeepSeek V4: Cost vs Quality - the 178x spread that only exists because of the meter
• The $400 Overnight Bill - what rationing looks like when it fails