Big Idea

The argument in one line.

The gauntlet loop is a three-line prompt pattern that has Claude fan out paired builder and critic sub-agents in a loop until every piece clears a quality bar, best used to polish an already-solid draft rather than to originate one from a blank page.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You already use Claude Code or Claude Desktop and want a copy-paste prompt structure for delegating multi-part builds to sub-agents.
You're experimenting with AI-built games, 3D scenes, or visual designs and want higher perceived polish without hand-holding every step.
You manage an agent workflow and want a concrete builder/critic loop pattern, not just the abstract idea of 'add a verifier'.

SKIP IF…

You're looking for a step-by-step game-dev tutorial — this is a prompting pattern, not a Three.js or Unity walkthrough.
You want proof this replaces professional design work — the video's own landing-page test shows the loop missing brand fit on a real client site.

TL;DR

The full version, fast.

The 'gauntlet loop' is a viral three-line prompt: state the task, have Claude fan out sub-agents with paired critics that loop per piece, and set a bar the critics must be utterly wowed by before stopping. It echoes Anthropic's 2024 'Building Effective Agents' builder/verifier idea, scaled to a full team of builder-critic pairs. Tested on a real-estate 3D walkthrough and a product landing page, it reliably raised visual polish over hours of looping — but on the landing page it drifted off the client's real brand system, showing the loop optimizes toward whatever bar you set, not toward being on brief. Best used as a polish pass on an existing MVP, not as the first prompt for a new build.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:43

01 · Intro

Cold open promising a viral new Claude prompting technique used to build custom 3D games.

00:43 – 02:25

02 · Where this came from

Traces the technique to Matt Schumer's viral Claude Opus 5 Call of Duty-level FPS demo and copycat 3D builds (Pokemon area, Mario Kart-style racer).

02:25 – 03:01

03 · Why Karpathy says this matters

Andrej Karpathy's post arguing these hyper-custom worlds mark a shift past toy LLM benchmarks like the pelican-on-a-bicycle SVG test.

03:01 – 04:01

04 · The gauntlet loop prompt, broken down

Matt Schumer's actual three-line prompt, decomposed into Task, Build Method, and Bar to Hit.

04:01 – 05:03

05 · Subagent orchestration in 3 levels

Level 1 (agent works, human verifies), Level 2 (agent works, agent verifies), Level 3 (agent team works, agent team verifies — the gauntlet loop).

05:03 – 07:23

06 · Anthropic called this back in 2024

Ties the pattern to Anthropic's 'Building Effective Agents' finding that a separate evaluator agent beats self-grading, plus a RoboNuggets community plug.

07:23 – 10:41

07 · Test 1: a real 3D apartment walkthrough

Feeds Claude a real floor plan and listing photos and runs a ~2-hour gauntlet loop building an explorable 3D walkthrough, blind-judged room by room against the real photos.

10:41 – 11:39

08 · Test 2: a product landing page

Applies the same prompt structure to a Ketone-IQ landing page build, running ~1 hour 19 minutes with sub-agents doing sections and fact-checking research.

11:39 – 12:57

09 · Where the gauntlet loop can go wrong

The landing page looked polished but missed the brand's real design system — the loop optimizes toward the bar you set, not toward an unstated brief.

12:57 – 13:30

10 · Get the skill

Points viewers to a free /gauntlet-loop skill that auto-generates this prompt structure for any task.

Atomic Insights

Lines worth screenshotting.

The gauntlet loop prompt has three parts: the task, a build method that fans out sub-agents with critic partners, and a bar to hit that decides when the loop stops.
Matt Schumer's viral Call of Duty-level 3D game demo was built by Claude Opus 5 with zero external assets, using only custom code.
Andrej Karpathy said these ultra-custom 3D worlds mark a shift away from the old 'SVG of a pelican on a bicycle' way of testing LLMs.
Anthropic's 2024 'Building Effective Agents' article already found that adding a separate evaluator agent produces better output than letting a model grade its own work.
The gauntlet loop scales that builder/verifier idea from one model checking itself to an entire fleet of builder-critic sub-agent pairs working in parallel.
A real-estate 3D walkthrough test ran for roughly two hours, with each room rebuilt and blind-judged against the real listing photos until a critic couldn't tell them apart.
On a product landing page test, the gauntlet loop produced a visually striking design that still missed the brand's actual visual identity.
A gauntlet loop only optimizes toward the bar you give it — a good-looking output that fails to match the brief still counts as a 'pass' by the loop's own logic.
The recommended way to use a gauntlet loop is as a polish pass on an existing minimum viable build, not as the prompt that originates the first draft.
Sub-agent orchestration has three levels: agent works and a human verifies, agent works and another agent verifies, or a full agent team works while a critic team verifies.

Takeaway

The gauntlet loop's builder-critic pattern is only as good as what you feed it.

AGENT PATTERNS

Fanning sub-agents into builder-critic pairs reliably raises polish through repeated critique, but it optimizes toward whatever bar you set, not toward a brief you never stated.

02Where this came from

The technique traces to Matt Schumer, who posted a Call of Duty-level 3D shooter built entirely by Claude Opus 5 with no external art assets.
Within days, other builders reused the same prompt structure to recreate a Pokemon starting area and a Mario Kart-style racing game in 3D.

03Why Karpathy says this matters

Andrej Karpathy pointed to these demos as evidence that LLM benchmarks are moving past toy tests like drawing a pelican on a bicycle.
The value isn't that anyone needs a hyper-custom 3D world — it's that AI models now have the patience to build something this labor-intensive on demand.

04The gauntlet loop prompt, broken down

The full working prompt is only three lines, and the pattern matters more than the exact wording.
Line one states the task; line two is the build method (fan out sub-agents, each with a critic); line three is the bar to hit that ends the loop.
The bar in the original prompt was explicit: don't stop until each sub-agent is utterly wowed compared side-by-side with a real Call of Duty game.

05Subagent orchestration in 3 levels

Level 1 is the default way most people prompt: the agent works, a human checks the output, and the human decides whether to send it back.
Level 2 replaces the human verifier with a second agent, so the loop runs without you checking every round.
Level 3, the gauntlet loop itself, scales that to a full team: multiple builder agents each paired with their own critic agent, working in parallel.

06Anthropic called this back in 2024

Anthropic's own 'Building Effective Agents' article found that adding a separate evaluator agent improves output quality versus letting a model judge its own work.
What's new isn't the builder/verifier idea itself — it's applying that idea at the scale of a whole fleet of paired sub-agents instead of one model checking itself.

07Test 1: a real 3D apartment walkthrough

The test fed Claude a real floor plan and listing photos from a Darling Point apartment and asked for an explorable 3D walkthrough.
The build method told Claude to break the space into the smallest pieces, fan out a sub-agent per piece, and have a separate critic compare each render against the real photo.
The run took about two hours, with a live progress page showing which rooms passed their critic round and which were still being reworked.
The finished walkthrough got close on layout and finishes like the marble kitchen counter, though textures on some rooms still needed more passes.

08Test 2: a product landing page

The same three-part prompt structure was applied to a Ketone-IQ product landing page build, running for about an hour and nineteen minutes.
Sub-agents fanned out to build sections and even ran research passes to verify product claims and numbers before finalizing copy.

09Where the gauntlet loop can go wrong

The landing page looked polished but didn't match Ketone-IQ's actual brand design system once compared side-by-side with their real site.
A gauntlet loop only knows how to satisfy the bar it's given — a striking result that ignores the brief still counts as a 'pass' to the loop.
The safer sequence is to start with a solid, on-brief minimum viable draft first, then run the gauntlet loop as a polish pass on that MVP rather than as the opening prompt.

Glossary

Terms worth knowing.

Gauntlet loop: A three-part prompt pattern (task, build method, bar-to-hit) that has an AI agent fan out sub-agents paired with critics, looping on each piece of a build until the critics can't find fault.
Sub-agent orchestration: Delegating pieces of a task to separate AI agent instances that work in parallel or in sequence, rather than handling the whole task inside a single agent conversation.
Builder-critic loop: A pattern where one agent produces work and a second, separate agent evaluates it against a standard, sending it back for revision until it passes.
Bar to hit: The stopping condition written into a looping prompt — the standard an output must clear before the agent is allowed to stop iterating and hand back a result.
Ultracode: An instruction used in the gauntlet loop prompt telling sub-agents to write exhaustive, highly detailed code rather than a minimal implementation.

Resources

Things they pointed at.

03:01linkMatt Schumer's gauntlet-loop write-up (somethingbig.ai) ↗

05:30linkAnthropic — "Building Effective Agents"

06:40channelRoboNuggets Community / Claude Code Masterclass ↗

12:57link/gauntlet-loop skill (free) ↗

13:20toolRUBRIC — command centre for AI agents ↗

Quotables

Lines you could clip.

02:30

“We're starting to leave the territory where you would test an LLM by creating an SVG of a pelican on a bicycle.”

instantly recognizable AI-benchmark reference that sets up the whole video's stakes→ TikTok hook↗ Tweet quote

02:43

“No one in their right mind would ever spend the time to write something this custom, but LLMs have all the stamina and patience in the world.”

clean, quotable thesis on why AI-native creative work looks different→ IG reel cold open↗ Tweet quote

11:40

“If you don't start with a really good minimum viable design or product, then what the gauntlet loop will do is just optimize towards probably the wrong thing.”

the entire caveat of the video in one line→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphoranalogy

There's a new prompting technique for Claude that's been blowing people's minds over the past week. Because in a single prompt, it can build fully playable games in hyper custom three d worlds like these that even Carpatty says might be the future of prompting LLMs. So today, I'll share with you this technique called the gauntlet loop, which might just be the quickest way for you to learn how to fan out sub agents to do work for you so that even if you're not into game development, you can add this tool to your arsenal and instantly get better at agentic AI.

And by the end, I'll share with you a skill that lets you fully take advantage of this technique in the easiest way possible. And if you're new, my name is Jay. I spent over a decade working with brands you may know.

I've been in AI since my masters in data science. Now I'm running an AI business and one of the largest AI communities globally. Let's dive into it.

So I first saw this prompting technique from Matt Schumer who posted this insane demo over at x where it already garnered something like 4,800,000 views. And he says here that Claude Opus five one shotted this entire game with everything you see in the demo being custom code without any single external asset.

And if Matt's name is familiar and if you're in the AI space for a while, that might be because he actually wrote this article called something big is happening, which a lot of people read a few months ago, now sitting at 87,000,000 views. Point being that he has been working with AI for quite a while already and is actually a good source from prompting techniques like these.

If you see a claim like this where an AI model supposedly one shots a game that looks as good as this, complete with sound, by the way. I'm not sure if you can hear that if I just turn on the sound. Usually, with this, your first reaction would be a bit skeptical if it was even made by AI, which is quite understandable because really the level of graphics here is already quite extraordinary.

But a few days ago, Matt actually shared this article where he went through how he created this game, and he's calling it the gauntlet loop. And since then, people have used that gauntlet loop prompting technique to recreate that same level of build quality. So to show a few examples, here's one where he recreated the starting area for Pokemon in Perfect three d.

Here is an example for a car racing simulator game, and this is one where it's more of like a Mario Kart type of game. And this is just crazy how well built this looks. Like, you can see the different textures of this environment, like with the road, the houses there, and there's just so much detail that the AI model was able to build out in this one game.

And you might not be into game development in particular, and later on, we'll show some use cases of how you can apply this outside of just video games. But personally, I still like to pay attention to these demos because it just points to how much raw capability these AI models now have. And Andre Carpatty was able to probably articulate it better than I can, where last weekend he made this post where he's saying that we're starting to leave the territory where you would test an LLM by creating an SVG of a pelican on a bicycle, which is this old test that AI models were used to be run on.

And he mentions here that these kinds of examples are great because no one in their right mind would ever spend the time to write something this custom, but LMs and AI models have all the stamina and patience in the world. So these hyper custom worlds and three d environments are a really great example of new capabilities that you yourself as an AI user are now able to tap into that you couldn't really do before.

So what is the Gauntlet Loop exactly? Well, thankfully, Matt also shared his exact prompt here, and surprisingly, it is quite simple.

It is only a three line prompt. And so you can see I just pasted that whole prompt in here. And what's actually more interesting here versus the actual verbiage of this prompt is just the pattern and structure of it.

Because if you really break this down into these three lines, essentially, what you have is a prompt structure that you can copy yourself, where first you give it a task of what you want to happen. In this case, the task that Matt was gunning for is to build a first person shooter game. And then the second part here is essentially the build method, So how that agent is going to achieve that task, where he's asking the main agent to fan out sub agents and have each of those tackle each task individually and to have a separate sub agent check it visually to ensure that it looks really, really good.

And then finally, the third part to this is the bar to hit, which is essentially the standard where the agent can decide when it can stop. And so he's saying here to not stop until each sub agent is utterly wowed with the quality when compared with the actual Call of Duty game. And what actually makes this gauntlet loop so effective are these two parts right here.

Because if you haven't tried using sub agents to orchestrate your work before, then this might just be one of the easiest and quickest way for you to try it out. But just to step back in case you don't know what we're referring to when we talk about sub agent orchestration, essentially, when you prompt an agent or talk to an AI model, there's three levels to it, at least in how I think about it.

The first level, which is the most basic and probably the most common, is when you do work with an agent. You send a prompt. It provides an output back to you, you verify if that output already matches your standard, and then you send another prompt until you get to what you want.

But it turns out this role of being the verifier can actually be offloaded to an agent as well. And so this concept of loops came about where if you take this to the next level, you can actually have an agent work for you and the agent also does the verification. And so this agent right here will assume the role of a critic and you'll just have these two AI agents talk to each other until it meets a certain standard, a bar that you set.

And only then will this critic agent actually pass to you the final output. And by the way, this whole idea of having a verifier agent in order to increase quality output is not new at all. In fact, this is an article by Entropic called Building Effective Agents.

And as a part of their study, they're mentioning here that same finding that they have where if you have an AI model generate the output, they actually find that you generally get better outputs if you have another AI model assume the role of an evaluator. And this is probably not surprising because if you think about how AI models usually behave, they usually convince themselves that the output that they generate is already good enough.

And so it turns out that having another model just validate that is actually good practice. And mind you, this was an article from way back in 2024. So the concept of looping isn't really new.

But what is newer and what this gauntlet loop has pretty much taken to the extreme level is that in the build method of that prompt, it's actually instructing the main agent, the one that you're talking to, to orchestrate and fan out to a fleet of sub agents with each of them having a critic partner in order to just make sure that the parts that they are creating are up to spec to the standard that you set before the final output comes to you.

And this is just a nice way to actually visualize what's really happening under the hood. But the great news about the tools that we have now like Claude Code is that for you to do something like this, you don't actually need to learn any extra technical tooling. All you need to do is have a well structured prompt like this where you're instructing the main agent to fan out sub agents, to have each of them tackle a task individually, and to have a separate sub agent check their work in order to meet this bar that you set.

And so if you dissect this gauntlet loop prompt, then I think that pattern is the one that's most important to learn here because there's really no reason for you to not adopt the same pattern across any of your builds. And so, obviously, I needed to try out this gauntlet loop prompt structure as well, and I actually wanted to try it in use cases beyond just games.

And by the way, if you want to learn how to build and sell AI systems that businesses actually pay for, then that's pretty much all we do over at the Robo Nuggets community, where not only do you get access to the Cloud Living Masterclass, which we update every week takes you from zero to mastery with the latest on AI, but you also get access to our agents as a service course, which walks you through how to actually get paid for all these AI skills that you are learning.

You also get to be part of a genuinely great community of AI builders. In fact, you can see just some of the recent wins our members are getting from the program right here. So if you want to start earning from AI, then check that just in the pinned comment below.

Now back to the video. And I think if this prompt is really good at virtual three d environments, then just a few months down the road as these models become even more capable, then this will probably have a huge impact on sectors like architecture or even real estate. And so the test that I put out for Opus five here is that I gave it this floor layout of a real real estate listing at Darling Point here in Sydney, and I also gave it some reference photos to match against.

So there's the living room, there's the bedroom, and so on. And then for the prompt itself, if you read through this, you can notice that it is the same structure as the gauntlet loop prompt where we have a task here at the top. We're saying here that we want Claude to build an explorable three d walkthrough of this apartment.

We're giving it the build method where we want the goal to be broken down into the smallest pieces and to fan out sub agents, and we're giving it that bar to hit where we won't stop until each critic is utterly wowed. So each sub agent will need to verify that that bar has been met.

And this whole prompt, I didn't write it myself, by the way. Near the end, I'll share with you a skill so that whatever task that you need, you can just instantly build a gauntlet loop prompt similar to this. And when I sent that prompt over, you can see that it created a plan here where it has these room builders sub agent and their corresponding partners, which are these blind critics.

And at least with the Claude desktop app, what's great about it is that you can actually view these dynamic workflows now as well where you can clearly see the phases that Claude has planned, where right now, it's working on the lighting and then the rooms, and then there is a phase where those sub agents will evaluate those rooms, and it will continue to loop up until that original bar that we've set has been satisfied.

Alright. So it ran for around two hours now, and it's still working, but I think it's already at a point where we can just showcase the strength of this prompt. Because if you can see here, this whole report, this HTML page, Claude just created for us in order to give us updates of what it's seeing versus its original peg.

So you can see this left one is the actual photo that we gave it, and this one on the right is the screenshots that it took of that three d world. It's already looking pretty close. Like the kitchen counter here, this is the original and this is the one that it created for us.

And even if it's already pretty close, it's actually still not satisfied. So you can see that this particular round is still marking as failed, and and it's actually still iterating and improving the look of this visual. And so you can see that's where the importance of setting a really high bar is because if you actually want this to be really perfect and you want to run this for a couple of hours in order to get a showcase build, then that's something that you could just let Claude do for you.

But since I don't wanna sit around here waiting for a few hours more just to complete this three d app, let's actually just view what it created for us here. And there you go. You can see we are in this living area.

It even captured the painting for us. Obviously, the couches are not perfect yet. But I think if we go around here, we can see the kitchen counter.

It has that marble finish. And remember, this whole thing was one shotted by Claude using that gauntlet loop prompt that we gave it. And just to show a sample view, so this is the kitchen counter, and this was the original peg that we gave to Claude.

So it's pretty close. Right? Then if you go to the bedroom, obviously, this texture probably can be improved in later passes, but I think it was able to capture at least the look and the size of the layout of the photo.

And again, just for reference, these are the images that we fed to Opus five. So that's pretty close at least in terms of the layout. And then this is the other bedroom, which for reference, this is the image that we fed it.

And probably if we gave it a bit more time, it'll probably be able to improve the textures of these some more. But that's just a quick demo of how you can use the gauntlet loop. Now apart from three d worlds and three d environments, what I also did is to just test out this gauntlet loop prompting structure to create a front end website design for this Ketone IQ product.

And when we launched this workflow, you can see it ran for around an hour and nineteen minutes. And it's the same thing where it fanned out several sub agents in order to create our website and also have this judging phase, which is essentially that evaluator agents to check the worker agents' builds. And what it created for us is this.

So let me just shift that so you can see. So we have the product here. We have Brain Fuel as the headline.

We have a dark mode and a light mode. And if we scroll down, we have these nice animations that just provide you some more details about this product. And I think what Opus did here is it actually fanned out some research agents in order to just make sure that these numbers are correct.

Now this is pretty good if you're just looking at the visual flare of it because obviously this is quite far already from the normal AI vibe coded designs that you may be used to or see. However, even though this looks pretty good, remember that visual flare is not really the only thing that brands or clients look for, especially when it comes to these websites.

Because if we were to look at Keton IQ's actual website, their brand design system is actually quite different. So I think the gauntlet loop can still help you out quite a lot.

But if you don't start with a really good minimum viable design or product, then what the gauntlet loop will do is just optimize towards probably the wrong thing. And this is really important to consider especially with powerful prompt structures like these.

Because if you notice, those Gauntlet loop prompt that we ran, in fact, any looping prompt that you run, they usually take a lot of time and tokens for them to finish. And so the way that I would use them moving forward personally is probably not to start with them as your initial prompt because what can happen there is even though the final output that you would get looks good, they might not actually be on brief and might be really far from what you want because you just let the agent decide the direction for you.

But if you start with a really strong minimum viable product or in this case a design system, which I've taught in previous other tutorials in this channel and in our community, then you can just introduce this gauntlet loop prompt as sort of a warp drive in terms of just sharpening or polishing the quality of that MVP so that the version two of the build that you're making not only looks good, but it is also sitting on a good foundation and is on brief.

And as mentioned, if you want to try out this gauntlet loop prompting for yourself, what I've done is to build out this skill called slash gauntlet loop. And what this skill does is whenever you use it, you can just give a particular task and it will create a gauntlet loop prompt for you. And you can just grab this down in the description below.

But there, hope that was useful and informative. And as always, thanks for watching until the end if you made it this far. And I'll see you next time.

Cheers.

The Hook

The bait, then the rug-pull.

A three-line prompt called the gauntlet loop has Claude fan out sub-agents in builder-critic pairs, looping until every piece clears a quality bar it sets for itself — the same pattern Anthropic described in 2024, just pushed to a full team.

Frameworks

Named ideas worth stealing.

03:01model

The Gauntlet Loop (Task / Build Method / Bar to Hit)

The Task (what to build)
The Build Method (fan out sub-agents + critics)
The Bar to Hit (when the loop can stop)

A three-line prompt structure: state the task, tell the agent to fan out sub-agents each paired with a harsh critic, and define the standard that ends the loop.

Steal forany multi-part AI build (design, code, content) you want to delegate and self-verify without checking every round yourself

04:01model