The Gauntlet Loop: The Builder-vs-Critic Prompt Behind Claude's Viral Game Demo

Three days after a founder named Matt Shumer posted a browser-based first-person shooter that Claude built from a single prompt, the demo had racked up millions of views — and a fair number of people insisted it had to be faked. It wasn’t. The game, nicknamed “Claude of Duty,” runs on Three.js, ships with zero hand-made 3D models, textures, or audio files, and weighed in around 55,000 lines of code across roughly a dozen subsystems, all generated by Claude Opus 5 working largely unsupervised for hours.

What made it possible wasn’t a secret model or a leaked feature. It was the prompt itself — a structure Shumer has since named the Gauntlet Loop, and it’s quietly become one of the more interesting prompting patterns to come out of 2026. Here’s what it actually is, where the idea really comes from, and why it’s easy to use it wrong.

Table of Contents

What actually happened with “Claude of Duty”

Shumer didn’t hand-code the FPS or babysit Claude through it level by level. He wrote one long orchestration prompt, pointed Claude Code at it, and let it run. Claude Code spawned multiple subagents, split the game into independent systems (movement, weapons, enemy AI, level geometry, lighting, and so on), built each piece, and — critically — checked its own work against a bar before calling anything finished. The repo hit over 1,500 GitHub stars and 250+ forks within three days, which is unusually fast even by 2026’s pace of AI-tool virality.

The interesting part for anyone who isn’t building games is that the same structure works for almost anything with a visual or checkable output: a landing page matched against a brand’s design system, a data pipeline matched against a spec, a 3D room walkthrough matched against real photos of the room. The game was the headline-grabbing demo. The prompt underneath it is the actual reusable idea.

Inside the Gauntlet Loop: builder, critic, bar

Strip away the branding and the Gauntlet Loop is a specific way of running the “evaluator-optimizer” pattern that Anthropic itself documented in its Building Effective Agents guide back in 2025 — one of five composable workflows the company recommends for agentic tasks, alongside prompt chaining, routing, parallelization, and orchestrator-workers. The Gauntlet Loop essentially fuses two of those: an orchestrator fans work out to builder subagents, and every piece of output then goes through an evaluator loop before it’s accepted.

A builder agent is given one narrow piece of the task — one room, one component, one system — and produces a real, checkable artifact, not just a description of one.
A separate critic agent, with fresh context and none of the builder’s reasoning or excuses, compares that artifact directly against a reference: a photo, a brand guideline, a spec, a benchmark. Ideally it’s a blind comparison, so the critic can’t be talked into a pass.
A bar is set in advance — explicit enough that “good enough” isn’t a judgment call the builder gets to make about its own work.
If the critic rejects it, the single biggest gap gets sent back for another pass. This repeats until the bar is met, the improvements stop being worth the cost, or an explicit boundary — time, token budget, or number of rounds — kicks in and stops the loop.

That last point matters more than it sounds. A loop with no exit condition doesn’t converge on quality — it just spends money until someone notices. The published versions of this prompt (there’s an open-source Gauntlet Loop skill on GitHub that packages it for Claude Code) all bake in explicit stopping conditions for exactly this reason.

Where it can quietly go wrong

A builder-critic loop is very good at one thing: closing the gap between what you have and whatever reference you gave it. It is not good at deciding what that reference should have been in the first place. Point it at the wrong starting design, the wrong brand guidelines, or a vague reference, and it will spend hours confidently polishing something that’s off-brief — just with more conviction each round.

This is the same warning that shows up in Anthropic’s own guidance on the evaluator-optimizer pattern: it earns its keep specifically when the evaluation criteria are clear and iteration genuinely adds value — not as a substitute for having a clear brief to begin with. The practical implication is that a gauntlet-style loop works best as a second pass, not a first draft. Get a real, human-approved minimum viable version — a rough layout, a first cut of a design system, a working sketch — locked in first. Then run the loop to sharpen it against a concrete reference, instead of asking it to invent the reference and the polish in the same breath.

There’s a cost dimension too. Multi-hour, multi-agent runs burn a lot more tokens than a single prompt-response exchange, and if you’re on usage-based API pricing rather than a flat subscription, that adds up fast — worth knowing before you kick off a run and walk away for the afternoon. If you’re deciding which Claude plan even gives you the room to run something like this, our ChatGPT vs Claude vs Gemini vs Perplexity pricing breakdown covers where the API-metered tiers sit relative to the flat subscription plans.

How to actually run one

You don’t need Shumer’s exact prompt to try the pattern — the structure is what matters:

Start with a real MVP. A rough version you already like the direction of, not a blank page — the loop refines, it doesn’t invent taste.
Give it something concrete to grade against. A screenshot, a set of reference photos, an existing brand style guide — something more specific than “make it look good.”
Break the task into independently checkable pieces so builder subagents can work on them in parallel instead of one long serial pass.
Keep the critic blind and separate. It should see the reference and the output, not the builder’s reasoning for why the output is close enough.
Set a real stopping condition — a time cap, a token budget, or a maximum number of rounds — before you hit run, not after you check back in three hours later.

Used this way, it stops being a party trick for viral demos and becomes what it actually is: an automated QA pass that keeps re-checking its own work against a target you already approved of.

Frequently asked questions

What is the Gauntlet Loop prompting technique?

The Gauntlet Loop is a multi-agent prompting pattern, named by Matt Shumer, where builder subagents produce work in parallel and a separate, fresh-context critic agent grades each piece against a concrete reference. Rejected work goes back for another round until it meets a pre-set bar or a stopping condition is hit.

Is the Gauntlet Loop an official Anthropic feature?

No. It’s a community prompting technique that runs on top of standard Claude Code subagents. It closely mirrors the orchestrator-workers and evaluator-optimizer patterns Anthropic documented in its own Building Effective Agents guide, but it isn’t a built-in product feature.

What was Claude of Duty?

Claude of Duty is a browser-based first-person shooter built in Three.js from a single Gauntlet Loop prompt run through Claude Opus 5. It has no hand-made 3D models, textures, or audio files, runs to roughly 55,000 lines of code, and was built largely unsupervised over several hours.

Should I start a project with a Gauntlet Loop prompt?

Generally no. The loop is best used to polish an already-approved starting point against a clear reference, not to decide direction from scratch. Starting with it risks hours of compute spent confidently perfecting something that’s off-brief.

Does running a Gauntlet Loop cost a lot?

It can. Multi-hour, multi-agent runs use significantly more tokens than a single prompt-response exchange, which matters most if you’re on usage-based API pricing rather than a flat monthly subscription. Setting an explicit time, token, or round-count boundary before starting keeps costs predictable.

The bottom line

The Gauntlet Loop isn’t magic, and it isn’t really about games. It’s a disciplined way of forcing an AI agent to check its own work against reality instead of grading its own homework — builder and critic kept deliberately separate, a real bar instead of a vibe, and a stopping point decided in advance. Claude of Duty is the viral proof it works. The more useful lesson is the boring one underneath it: give the loop a strong starting point and a real reference, and it’ll spend its hours closing the gap instead of wandering off in the wrong direction.

Have you tried running a builder-critic loop on your own project? Tell us how it went in the comments, and subscribe to ournationonline for more practical breakdowns of how people are actually using AI in 2026.