The bottleneck moved from model capability to cost efficiency

For as long as I’ve been doing agentic development, the bottleneck was me. My time, my attention, my willingness to click through the app one more time to check if the thing actually works. This week that changed. My own input finally stopped being the limiting factor, and I ran straight into the next bottleneck.

The loop I kept repeating by hand

At some point I noticed that I run basically the same workflow for everything I work on:

1. Use Claude Code to write up a bunch of issues
2. Start a fresh session, point it at one issue, let it implement a solution
3. Verify the solution myself: click through the UI, look into the database
4. Find more things that need fixing, go back and forth with the agent for a few iterations
5. Once it works, let the agent simplify its own code
6. Start another fresh session and let a second agent review what we built
7. Review the findings, let it fix the ones I agree with, and re-verify every fix myself on my dev server
8. Create a PR, run CI, and when something fails, prompt the agent to fix it

If you read that closely, you’ll notice how much of it is me: prompting, verifying, babysitting.

The agents did the typing, but I was the micromanager. And since this is the same flow for almost every issue, the obvious move was to turn it into a slash command and let the agent run the whole loop itself.

Why I didn’t do this months ago

I actually tried, back with Opus 4.5. It went badly. When the agent had to navigate the app I’m building, it couldn’t even get past the login screen reliably. Worse: it would confidently claim that things worked when they very obviously didn’t. Once a model lies to you about a green checkmark, the whole idea of self-verification is dead. You can’t build an autonomous loop on top of a verifier you don’t trust.

So the workflow stayed manual.

Then Opus 4.8 came along and was noticeably better, and Fable 5 honestly impressed me enough to give the whole thing another shot. This time it worked.

I encoded the full flow (implement, verify, iterate, simplify, review, fix, PR, CI) into a single command. The one thing I added was a clarification gate: before implementing anything, the agent can come back to me with questions about the issue. That alone catches most of the misunderstandings that used to cost me an iteration or two.

Especially with Fable 5, the PRs coming out of this loop look good right off the bat. Not “good for an AI” good. Just good.

And then I hit the new bottleneck

Each of these self-verifying sessions runs 30–60 minutes, because the agent is doing all the checking I used to do. Which means I can finally run work in parallel, 4 to 6 sessions at once. For the first time, my personal input wasn’t the limiting factor anymore.

The limiting factor is now money.

I’m on the $200 Claude plan and I had never hit its usage limits before. Now I hit them fast.

This was the first time I genuinely felt: if I spend more money, I get more work done. Not better tools, not more convenience. More shipped work, almost linearly.

Around the same time, a comparison crossed my Twitter feed that shows what these subscriptions actually cost the providers. It estimates the maximum API-equivalent inference you can squeeze out of each plan.

The order of magnitude is the point. A $200 Claude subscription translates to roughly $8,000 worth of API inference. The equivalent OpenAI plan reaches around $14,000! These subscriptions are heavily subsidized, and anyone using them at the intensity that agentic workflows now make possible is burning far more compute than they’re paying for.

We don’t need smarter models. We need cheaper ones.

Here’s the thing I now believe from first-hand experience: for my day-to-day development work, the models don’t have to get much better than Fable 5. The capability is there. What’s missing is the ability to afford running it at full throttle, all day, in parallel.

So my wish for the AI labs is simple: take the intelligence we already have and get it into, or onto, something that costs dramatically less to run. Cheaper inference, distillation, better hardware utilization, whatever it takes. I think whichever company seriously commits to this next will have a massive advantage over its competitors. Because with models at the Fable 5 level, the question stops being “what can AI do?” and becomes “how much intelligence can I afford, and how much should I?”

Where this is all heading

You can already see the next stage of this on Twitter. The AI crowd isn’t talking about self-verification loops anymore. That’s apparently old news. The discourse has moved on to letting agents run in loops until a win condition is met, and to the idea that developers shouldn’t be prompting at all. Peter Steinberger put it bluntly: stop prompting coding agents, start designing the loops that prompt them for you.

Some go further: agents should proactively prioritize incoming issues, implement solutions, even merge them automatically based on their own judgment. No human in the loop unless something escalates.

Cool vision. But look at what it costs. Steinberger’s token spend for his OpenClaw development is public, and it’s the kind of number that makes your CFO’s eye twitch. Over a million dollars of inference in 30 days.

That’s not a workflow your average company can reasonably pay for. It’s a preview of where the workflows are going, running on a budget almost nobody has.

Which brings me back to my point. The frontier of capability is in a pretty good place. The frontier that actually matters now is cost. I really hope the AI companies take that challenge as seriously as they took the benchmarks. Ideally a bit more seriously, given how well some of those coding benchmarks have held up under scrutiny.