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 and hyper custom 3D

worlds like these that even Karpati 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

[music] 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, have 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. [music]

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.8 million views. And he

says here that Claude Opus 5 oneshotted

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 million 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. And if you see a claim like

this where an AI model supposedly

oneshots 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 Pokémon

in Perfect 3D. 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

wellbuilt 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 Karpati

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

3D 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 threeline 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 going for

is to build a firsterson shooter game.

And then the second part here is

essentially the build method. to 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 is actually

instructing the main agent, the one that

you are 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

to have a well ststructured 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 Robbernuggets community,

where not only do you get access to the

Claude Living Master Class, which we

update every week and 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 pin comment below. Now, back to the

video. And I think if this prompt is

really good at virtual 3D 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 5 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 3D 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 aent 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 gaunt to the loop prompt similar

to this. And when I send that prompt

over, you can see that it created a plan

here where it has these room builder sub

agent and their corresponding partners,

which are these blind critics. And at

least with a 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. All right, so it

ran for around 2 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 uh Claw 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 3D world. And 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,

it's 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 can just let Claude

do for you. But since I don't want to

sit around here waiting for a few hours

more just to complete this 3D 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 oneshotted 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 we 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 5. 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 3D worlds and 3D

environments, what I also did is to just

test out this gauntlet loop prompting

structure to create a front-end website

designed for this ketone IQ product. And

when we launched this workflow, you can

see it ran for around an hour and 19

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 vibecoded

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

to look at Ketone 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 slashgauntlet 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, I hope that was useful and

informative. And as always, thanks for

watching until the end if you made it

this far. I'll see you next time.

Cheers. [music]