Anthropic's three-agent loop is the lesson. The 40-minute app is the distraction.

Anthropic engineers ran a live demo building a full app from scratch in roughly 40 minutes, using three agents in a loop: one plans the work, one builds it, one judges the result, cycling until the app actually works. The clip came from people on the team behind Claude Code and pulled 1.9 million views. The line everyone quoted afterward was "the winners won't have the smartest model, they'll have the best loop."

That line is correct. The demo's framing buries it under a stopwatch.

Why the loop beats the model

The eye-catching part is the 40 minutes. The useful part is the structure. A single strong model running one pass over a prompt produces confident code that compiles and fails. The thing that fixes this is not a bigger model, it's a critic in the loop that rejects the build and sends it back.

That third agent, the judge, is the load-bearing piece of a plan-build-judge setup. Without it you have a planner handing work to a builder with nothing checking whether the output meets the spec. With it, the loop has a stopping condition that maps to reality: keep cycling until the tests pass, then ship. The "smartest model vs best loop" framing is a real claim about where the marginal gains now live, and I think it's directionally true for most app-building work today.

The reason this works is mundane. Each agent has one job and a narrow context, so it's easier to keep on task than one agent juggling planning, writing, and self-grading at once. The judge gets to be adversarial because it didn't write the code. That separation is most of the value.

The numbers I don't trust

Here's where I split from the hype. A related tweet from the same author quotes Anthropic's Head of Product calling Fable 5 "the best model we've ever shipped for agentic work" and claiming "our engineers now ship 8x more code than they did in past years." ^[1]

I'd treat that 8x figure as marketing until proven otherwise. It arrives with no methodology, no definition of "code," and no baseline. It's a tweet, not a changelog or an engineering writeup. The same goes for the original demo: a 40-minute build with no detail on the app's complexity, the test suite, or how many loop iterations it took tells you the pattern is plausible, not that it's reliable on your codebase. The demo got 8,939 likes, which measures reach, not reproducibility. ^[2]

This matters because the architecture is genuinely good and the surrounding claims are unverified. You can adopt the first without buying the second.

What's actually new here, and what isn't

The agent loop is not a 2026 invention. Plan-build-judge is a relabeling of the generate-and-verify pattern that ML practitioners have run for years, now packaged as named agents. What's new is that the models are finally good enough at each role that the loop converges in minutes instead of thrashing. The contribution of the demo is the demonstration, not the idea.

So I'd resist the implied conclusion that you need Anthropic's latest model to do this. The loop is model-agnostic. You can build a plan-build-judge cycle today on whatever model you already run, and the judge step is where you'll get most of the lift regardless of model tier. The promotional framing ties the technique to a specific model launch; the technique doesn't need it.

If you're building on this today

1. Add a judge before you add anything else. If your current setup has a planner and a builder but no separate critic, that's your highest-leverage change. Make the judge run the actual tests, not just read the code.
2. Stop the loop on a real signal. Cycle until tests pass or a hard iteration cap triggers, not after a fixed number of rounds. A fixed count either quits early or burns tokens after the work is done.
3. Keep each agent's context narrow. The whole reason the loop beats one clever pass is role separation. Don't let the builder grade itself.
4. Ignore the throughput numbers and measure your own. The 8x and the 40 minutes are someone else's demo. Run the loop on a task you know, count the iterations, and decide from that.

The signal in this demo is solid and the packaging is loud. Take the agent loop, leave the stopwatch.

Sources

Primary source: Anatoli Kopadze (@AnatoliKopadze) on X

1. Tweet by @AnatoliKopadze — @AnatoliKopadze · community
2. Tweet by @AnatoliKopadze — @AnatoliKopadze · community
3. Tweet by @expertwith_AI — @expertwith_AI · community