「Gauntlet-loop」透過將任務拆解、分派子代理協作、並以嚴格的自我批判門檻進行迭代，迫使 AI 在單一提示中產出堪比專業開發的 3D 遊戲與互動場景，揭示提示工程已從單次問答進化為自主品質控制的平行代理體系。
- 現象級演示與技術來源：Matt Schumer 以 Claude Opus 5 一次性生成第一人稱射擊遊戲，完整自訂程式碼與素材，在社群引發數百萬關注，並公開了其命名為「gauntlet-loop」的核心提示。
- Gauntlet-loop 的三層提示結構：提示由明確的「任務」、「建構方法」（要求主代理分派子代理、每子代理配備驗證者）以及「品質門檻」（直到每個子代理被驚豔為止）所構成，形成一個嚴苛的自動化優化迴圈。
- 代理協作與驗證者模式的理論基礎：此技術整合了代理循環與評估者角色的概念，靈感來自 Anthropic 的「構建有效代理」研究，透過將生成與評判分離，克服了 LLM 自我滿足的傾向。
- 跨領域應用實測：作者將同樣的提示結構應用於房地產 3D 虛擬導覽與 Shopify 網站前端設計，結果顯示出高度擬真的空間還原能力，但也暴露出若無明確設計基準，優化可能偏離品牌調性。
- 關鍵實戰心法：先 MVP，後 warp drive：避免在無穩固基礎的狀態下直接使用 gauntlet-loop，因大量耗費時間與代幣的迴圈容易使產出偏離原意；應先建立最低可行產品（MVP），再以此提示作為品質涅槃的推進器。
- 技術民主化與工具化：作者提供了名為
/gauntlet-loop 的技能工具，能自動將任意任務轉化為 gauntlet-loop 提示，大幅降低了使用門檻，預示此類高階提示即服務（Prompt-as-a-Skill）的趨勢。
- 對未來人機協作的啟示：Andrej Karpathy 等意見領袖指出，這種能夠生成高度客製化內容的能力，象徵著人類開始利用 AI 的無限耐心進入過去無法觸及的創作領域。
- 風險與成本意識：長時間代理迴圈帶來的 inferencing 成本與不確定性，要求使用者必須謹慎設定任務邊界與評估條件，否則可能導致資源浪費。
-
提示工程的結構性突破：從指令到管理框架
Gauntlet-loop 的核心不在於神秘的咒語，而是將「管理」思維注入提示結構。傳統提示多為線性指令，而此模式將人類專案管理的分工（拆解、派發、檢查、循環改善）翻譯為代理可執行的後設指令。這種三位一體的結構（任務─建構方法─品質閾值）實際上是為 LLM 內建了一套簡易的作業系統，讓它能對自身輸出進行排程與品質保證。這標誌著提示工程從單純的語言技巧，躍升為基於工作流設計的元程式設計，其可複製性與跨任務泛用性是過去單點提示無法比擬的。
-
代理協同的極致化：盲從批評家與過度優化的陷阱
此技巧的精髓在於「每個子代理都配備一個盲眼批評家」的設計，強制每一部分都必須通過另一個模型（或歷程）的嚴厲審視。然而，這種純粹以「驚豔」為門檻的設定，若不輔以明確的客觀指標或風格指南，很容易墮入 overfitting 到 LLM 內部美感 的陷阱。實測中網站設計雖炫麗卻偏離品牌就是明證。真正的風險在於，當評判標準本身由同一基礎模型給出，可能形成「同溫層」效應，產出僅對 AI 自身有意義的高度內卷結果，而非對人類使用者真正有效的產出。
-
成本與時間的黑暗面：被忽視的代理通膨
影片中提到一個建物導覽跑了兩小時仍持續優化，這背後代表著極高的 token 耗用與推理成本。在多代理架構中，代理間互動與驗證迴圈會使總運算量呈指數成長，若未設定明確的「最大迭代」或「資源上限」，很容易形成計算黑洞。對於商業應用而言，需在「最終成果的完美程度」與「邊際改善成本」之間找到平衡。目前 Gauntlet-loop 更像是一台無視成本的超級跑車，適合展示科技極限，但在一般生產環境推廣前，亟需融入自適應終止條件與資源感知機制。
-
3D 生成能力對物理世界的衝擊前兆
透過房屋平面圖與參考照片即生成可探索 3D 場景，暗示著空間智能與生成式技術的融合即將到來。即使當前紋理仍有瑕疵，其對空間佈局與參考圖還原的精準度已展現雛形。未來數月當底層模型空間理解力更成熟時，此提示模式將能直接應用於建築設計、室內裝修策劃、甚至拍賣前的虛擬佈展。這將徹底改變房地產、設計等行業的展示邏輯，使得即時、個人化的空間敘事成為可能，但其法律責任（如誤導購買者）與參照真實性的倫理問題也將隨之浮現。
-
人機協作中的權力偏移：誰是真正的總監？
Gauntlet-loop 強化了 AI 代理在「執行」與「判斷」兩端的自主性，人類看似退居為只給出大方向與最終目標的角色。但透過 MVP 先行的概念可知，人類真正的不可取代性在於品味的設定與方向的校準。若完全放任代理從零開始，等於將創意主導權讓渡給模型。未來最具生產力的模式，將是人類作為創意總監，先提供設計系統與核心價值，再利用 Gauntlet-loop 進行極致的品質迭代。這再次確認了專業知識在素人與 AI 協作中的價值，越能提供精確「設計 DNA」的人，越能槓桿此技術的能量。
| 概念 |
說明 |
| Gauntlet-loop |
一種三層結構提示，包含任務、子代理分派與驗證方法、以「驚豔」為尺度的品質門檻，強制 AI 進行極高標準的自我迭代。 |
| 子代理（Sub-agent） |
由主代理根據任務拆解後動態派生的平行工作單元，各自負責一項子任務，並可擁有自己的驗證夥伴。 |
| 評估者代理（Critic/Evaluator） |
專責檢查子代理輸出的另一個模型歷程，用以打破「自產自評」的偏誤迴路，提升最終輸出品質。 |
| Claude Opus 5 |
本次測試所使用的高階語言模型，展現出理解後設指令、自主劃分工作、動態生成複雜程式碼與 3D 場景的能力。 |
| Anthropic 代理指南 |
官方文件《Building effective agents》，強調在生成環境中引入評估者角色的有效性，為 gauntlet-loop 提供理論背書。 |
| MVP 先行策略 |
建議先用簡單提示產生基礎可用的原型（MVP），再套用 gauntlet-loop 進行品質打磨，以避免方向偏差與成本浪費。 |
/gauntlet-loop 技能 |
將 gauntlet-loop 模式封裝為可重複呼叫的指令，輸入任意任務即可輸出對應結構的提示，加速推廣與應用。 |
Gauntlet-loop 的意義不僅是遊戲開發圈的狂歡，它揭示了一條清晰的道路：產生式 AI 的應用門檻正從「會寫程式」移轉至「會設計嚴謹的自動化品質流程」。對於企業與開發者而言，過往必須投入大量人力進行細節雕琢與多輪審查的工作，現在可被一個經過巧妙設計的提示在數小時內完成，甚至達到超越人類耐心的完成度。然而，這並不代表專業角色的消失，反而凸顯了前期設計（如品牌規範、使用者體驗準則）的關鍵性，因為驅動這些自律代理群的，正是那些無法妥協的標準。
從更廣的視角看，此技術預示著軟體與數位內容生產將步入「提示即生產線」的時代。房地產、電商、建築視覺化等領域，能透過簡單的平面圖與風格圖片，即時產生高度沉浸的體驗原型，大幅降低試錯成本並加速決策。但企業在導入時必須建立新的評估指標：不僅看最終產出是否「驚豔」，還需監測代理運作過程的資源效率、合規性以及品牌一致性，否則可能換來一個精美卻完全無用的產物。未來，能夠將設計系統、評估邏輯與業務知識封裝為可重用「驗證代理」的團隊，將握有極大優勢。
- “No one in their right mind would ever spend the time to write something this custom. But LLMs and AI models have all the stamina and patience in the world.” — Andrej Karpathy
- “Don't stop until each sub-agent is utterly wowed with the quality when compared with the actual Call of Duty game.” — Matt Schumer 的 gauntlet-loop 提示片段
- “Start with a really strong minimum viable product… then you can just introduce this gauntlet loop prompt as sort of a warp drive in terms of just sharpening or polishing the quality.” — 影片創作者 Jay
點擊展開完整字幕
0:00 There's a new prompting technique for
0:01 Claude that's been blowing people's
0:02 minds over the past week. Because in a
0:05 single prompt, it can build fully
0:06 playable games and hyper custom 3D
0:08 worlds like these that even Karpati says
0:11 might be the future of prompting LLMs.
0:13 So today, I'll share with you this
0:15 technique called the gauntlet loop,
0:16 which might just be the quickest way for
0:18 you to learn how to fan out sub agents
0:20 to do work for you, so that even if
0:22 you're not into game development, you
0:23 can add this tool to your arsenal and
0:25 instantly get better at agentic AI. And
0:27 by the end, I'll share with you a skill
0:29 that lets you fully take advantage
0:30 [music] of this technique in the easiest
0:32 way possible. And if you're new, my name
0:34 is Jay. I spent over a decade working
0:35 with brands you may know, have been in
0:37 AI since my masters in data science. Now
0:39 I'm running an AI business and one of
0:40 the largest AI communities globally.
0:42 Let's dive into it. [music]
0:45 So, I first saw this prompting technique
0:47 from Matt Schumer who posted this insane
0:49 demo over at X where it already garnered
0:51 something like 4.8 million views. And he
0:54 says here that Claude Opus 5 oneshotted
0:56 this entire game with everything you see
0:58 in the demo being custom code without
1:00 any single external asset. And if Matt's
1:02 name is familiar and if you're in the AI
1:04 space for a while, that might be because
1:05 he actually wrote this article called
1:07 something big is happening which a lot
1:08 of people read a few months ago now
1:10 sitting at 87 million views. Point being
1:12 that he has been working with AI for
1:14 quite a while already and is actually a
1:16 good source from prompting techniques
1:17 like these. And if you see a claim like
1:19 this where an AI model supposedly
1:20 oneshots a game that looks as good as
1:22 this, complete with sound. By the way,
1:24 I'm not sure if you can hear that if I
1:25 just turn on the sound. Usually with
1:27 this, your first reaction would be a bit
1:29 skeptical if it was even made by AI,
1:31 which is quite understandable because
1:33 really the level of graphics here is
1:34 already quite extraordinary. But a few
1:36 days ago, Matt actually shared this
1:38 article where he went through how he
1:40 created this game and he's calling it
1:42 the gauntlet loop. And since then,
1:43 people have used that gauntlet loop
1:45 prompting technique to recreate that
1:47 same level of build quality. So, to show
1:49 a few examples, here's one where he
1:51 recreated the starting area for Pokémon
1:53 in Perfect 3D. Here is an example for a
1:55 car racing simulator game. And this is
1:57 one where it's more of like a Mario Kart
1:59 type of game. And this is just crazy how
2:01 wellbuilt this looks. Like, you can see
2:03 the different textures of this
2:04 environment, like with the road, the
2:05 houses there. And there's just so much
2:07 detail that the AI model was able to
2:09 build out in this one game. And you
2:10 might not be into game development in
2:12 particular. And later on, we'll show
2:14 some use cases of how you can apply this
2:16 outside of just video games. But
2:18 personally, I still like to pay
2:19 attention to these demos because it just
2:21 points to how much raw capability these
2:23 AI models now have. And Andre Karpati
2:26 was able to probably articulate it
2:27 better than I can where last weekend he
2:30 made this post where he's saying that
2:31 we're starting to leave the territory
2:33 where you would test an LLM by creating
2:35 an SVG of a pelican on a bicycle, which
2:37 is this old test that AI models were
2:39 used to be run on. And he mentions here
2:41 that these kinds of examples are great
2:43 because no one in their right mind would
2:44 ever spend the time to write something
2:46 this custom. But LMS and AI models have
2:49 all the stamina and patience in the
2:50 world. So these hyper custom worlds and
2:52 3D environments are a really great
2:54 example of new capabilities that you
2:56 yourself as an AI user are now able to
2:58 tap into that you couldn't really do
3:00 before. So what is the gauntlet loop
3:02 exactly? Well, thankfully Matt also
3:04 shared his exact prompt here. And
3:06 surprisingly it is quite simple. It is
3:08 only a threeline prompt. And so you can
3:11 see I just pasted that whole prompt in
3:12 here. And what's actually more
3:13 interesting here versus the actual
3:15 verbiage of this prompt is just the
3:17 pattern and structure of it. Because if
3:19 you really break this down into these
3:21 three lines, essentially what you have
3:22 is a prompt structure that you can copy
3:24 yourself where first you give it a task
3:26 of what you want to happen. In this
3:28 case, the task that Matt was going for
3:29 is to build a firsterson shooter game.
3:32 And then the second part here is
3:33 essentially the build method. to how
3:35 that agent is going to achieve that task
3:37 where he's asking the main agent to fan
3:39 out sub agents and have each of those
3:41 tackle each task individually and to
3:43 have a separate sub agent check it
3:45 visually to ensure that it looks really
3:47 really good. And then finally, the third
3:49 part to this is the bar to hit, which is
3:51 essentially the standard where the agent
3:52 can decide when it can stop. And so he's
3:55 saying here to not stop until each sub
3:57 agent is utterly wowed with the quality
3:59 when compared with the actual Call of
4:01 Duty game. And what actually makes this
4:02 gauntlet loop so effective are these two
4:05 parts right here. Because if you haven't
4:06 tried using sub agents to orchestrate
4:08 your work before, then this might just
4:10 be one of the easiest and quickest way
4:12 for you to try it out. But just to step
4:13 back in case you don't know what we're
4:15 referring to when we talk about sub
4:16 agent orchestration. Essentially, when
4:18 you prompt an agent or talk to an AI
4:20 model, there's three levels to it. At
4:22 least in how I think about it. The first
4:24 level, which is the most basic and
4:26 probably the most common, is when you do
4:27 work with an agent, you send a prompt.
4:29 It provides an output back to you. You
4:31 verify if that output already matches
4:33 your standard and then you send another
4:34 prompt until you get to what you want.
4:36 But it turns out this role of being the
4:38 verifier can actually be offloaded to an
4:41 agent as well. And so this concept of
4:43 loops came about where if you take this
4:45 to the next level, you can actually have
4:46 an agent work for you and the agent also
4:49 does the verification. And so this agent
4:51 right here will assume the role of a
4:53 critic and you'll just have these two AI
4:55 agents talk to each other until it meets
4:57 a certain standard, a bar that you set.
4:59 And only then will this critic agent
5:01 actually pass to you the final output.
5:03 And by the way, this whole idea of
5:04 having a verifier agent in order to
5:06 increase quality output is not new at
5:09 all. In fact, this is an article by
5:10 Entropic called building effective
5:12 agents. And as a part of their study,
5:13 they're mentioning here that same
5:15 finding that they have where if you have
5:17 an AI model generate the output. They
5:19 actually find that you generally get
5:20 better outputs if you have another AI
5:22 model assume the role of an evaluator.
5:25 And this is probably not surprising
5:26 because if you think about how AI models
5:29 usually behave, they usually convince
5:30 themselves that the output that they
5:32 generate is already good enough. And so
5:34 it turns out that having another model
5:35 just validate that is actually good
5:37 practice. And mind you, this was an
5:39 article from way back in 2024. So the
5:42 concept of looping isn't really new. But
5:44 what is newer and what this gauntlet
5:46 loop has pretty much taken to the
5:48 extreme level is that in the build
5:49 method of that prompt is actually
5:51 instructing the main agent, the one that
5:53 you are talking to, to orchestrate and
5:55 fan out to a fleet of sub agents with
5:58 each of them having a critic partner in
5:59 order to just make sure that the parts
6:01 that they are creating are up to spec to
6:03 the standard that you set before the
6:05 final output comes to you. And this is
6:07 just a nice way to actually visualize
6:09 what's really happening under the hood.
6:10 But the great news about the tools that
6:12 we have now like claude code is that for
6:14 you to do something like this, you don't
6:15 actually need to learn any extra
6:17 technical tooling. All you need to do is
6:19 to have a well ststructured prompt like
6:21 this where you're instructing the main
6:22 agent to fan out sub agents to have each
6:25 of them tackle a task individually and
6:27 to have a separate sub agent check their
6:29 work in order to meet this bar that you
6:32 set. And so if you dissect this gauntlet
6:33 loop prompt, then I think that pattern
6:35 is the one that's most important to
6:37 learn here because there's really no
6:38 reason for you to not adopt the same
6:40 pattern across any of your builds. And
6:42 so obviously I needed to try out this
6:44 gauntlet loop prompt structure as well.
6:46 And I actually wanted to try it in use
6:48 cases beyond just games. And by the way,
6:49 if you want to learn how to build and
6:51 sell AI systems that businesses actually
6:53 pay for, then that's pretty much all we
6:55 do over at the Robbernuggets community,
6:56 where not only do you get access to the
6:58 Claude Living Master Class, which we
7:00 update every week and takes you from
7:01 zero to mastery with the latest on AI,
7:03 but you also get access to our agents as
7:05 a service course, which walks you
7:07 through how to actually get paid for all
7:09 these AI skills that you are learning.
7:10 You also get to be part of a genuinely
7:12 great community of AI builders. In fact,
7:14 you can see just some of the recent wins
7:16 our members are getting from the program
7:18 right here. So, if you want to start
7:19 earning from AI, then check that just in
7:20 the pin comment below. Now, back to the
7:22 video. And I think if this prompt is
7:24 really good at virtual 3D environments,
7:25 then just a few months down the road as
7:27 these models become even more capable,
7:29 then this will probably have a huge
7:30 impact on sectors like architecture or
7:32 even real estate. And so, the test that
7:34 I put out for Opus 5 here is that I gave
7:36 it this floor layout of a real real
7:38 estate listing at Darling Point here in
7:40 Sydney. And I also gave it some
7:42 reference photos to match against. So,
7:44 there's the living room, there's the
7:45 bedroom, and so on. And then for the
7:47 prompt itself, if you read through this,
7:48 you can notice that it is the same
7:50 structure as the gauntlet loop prompt
7:51 where we have a task here at the top.
7:53 We're saying here that we want Claude to
7:54 build an explorable 3D walkthrough of
7:56 this apartment. We're giving it the
7:58 build method where we want the goal to
7:59 be broken down into the smallest pieces
8:01 and to fan out sub agents. And we're
8:03 giving it that bar to hit where we won't
8:05 stop until each critic is utterly wowed.
8:07 So each sub aent will need to verify
8:09 that that bar has been met. And this
8:11 whole prompt, I didn't write it myself,
8:13 by the way. Near the end, I'll share
8:14 with you a skill so that whatever task
8:15 that you need, you can just instantly
8:17 build a gaunt to the loop prompt similar
8:18 to this. And when I send that prompt
8:20 over, you can see that it created a plan
8:22 here where it has these room builder sub
8:24 agent and their corresponding partners,
8:26 which are these blind critics. And at
8:28 least with a Claude desktop app, what's
8:29 great about it is that you can actually
8:31 view these dynamic workflows now as well
8:33 where you can clearly see the phases
8:35 that Claude has planned where right now
8:37 it's working on the lighting and then
8:38 the rooms and then there is a phase
8:40 where those sub agents will evaluate
8:41 those rooms and it will continue to loop
8:43 up until that original bar that we've
8:45 set has been satisfied. All right, so it
8:47 ran for around 2 hours now and it's
8:49 still working. But I think it's already
8:51 at a point where we can just showcase
8:52 the strength of this prompt because if
8:54 you can see here, this whole report,
8:55 this HTML page uh Claw just created for
8:58 us in order to give us updates of what
9:00 it's seeing versus its original peg. So
9:02 you can see this left one is the actual
9:04 photo that we gave it. And this one on
9:06 the right is the screenshots that it
9:07 took of that 3D world. And it's already
9:09 looking pretty close. Like the kitchen
9:11 counter here, this is the original and
9:13 this is the one that it created for us.
9:15 And even if it's already pretty close,
9:17 it's actually still not satisfied. So
9:19 you can see that this particular round,
9:21 it's still marking as failed and and
9:23 it's actually still iterating and
9:24 improving the look of this visual. And
9:26 so you can see that's where the
9:27 importance of setting a really high bar
9:30 is because if you actually want this to
9:32 be really perfect and you want to run
9:33 this for a couple of hours in order to
9:35 get a showcase build, then that's
9:37 something that you can just let Claude
9:38 do for you. But since I don't want to
9:40 sit around here waiting for a few hours
9:42 more just to complete this 3D app, let's
9:44 actually just view what it created for
9:45 us here. And there you go. You can see
9:47 we are in this living area. It even
9:50 captured the painting for us. Obviously,
9:52 the couches are not perfect yet, but I
9:54 think if we go around here, we can see
9:56 the kitchen counter. It has that marble
9:58 finish. And remember, this whole thing
10:00 was oneshotted by Claude using that
10:01 gauntlet loop prompt that we gave it.
10:03 And just to show a sample view. So, this
10:06 is the kitchen counter. And this was the
10:08 original peg that we gave to Claude. So,
10:10 it's pretty close, right? Then if we go
10:12 to the bedroom, obviously this texture
10:14 probably can be improved in later
10:16 passes, but I think it was able to
10:18 capture at least the look and the size
10:20 of the layout of the photo. And again,
10:22 just for reference, these are the images
10:24 that we fed to Opus 5. So that's pretty
10:27 close, at least in terms of the layout.
10:29 And then this is the other bedroom,
10:31 which for reference, this is the image
10:33 that we fed it. And probably if we gave
10:35 it a bit more time, it'll probably be
10:36 able to improve the textures of these
10:38 some more. But that's just a quick demo
10:40 of how you can use the gauntlet loop.
10:42 Now, apart from 3D worlds and 3D
10:44 environments, what I also did is to just
10:46 test out this gauntlet loop prompting
10:47 structure to create a front-end website
10:49 designed for this ketone IQ product. And
10:52 when we launched this workflow, you can
10:54 see it ran for around an hour and 19
10:56 minutes. And it's the same thing where
10:57 it fanned out several sub agents in
10:59 order to create our website and also
11:02 have this judging phase which is
11:04 essentially that evaluator agents to
11:06 check the worker agents builds. And what
11:08 it created for us is this. So let me
11:10 just shift that so you can see. So we
11:12 have the product here. We have brain
11:13 fuel as the headline. We have a dark
11:15 mode and a light mode. And if we scroll
11:17 down, we have these nice animations that
11:19 just provide you some more details about
11:21 this product. And I think what Opus did
11:23 here is it actually fanned out some
11:25 research agents in order to just make
11:27 sure that these numbers are correct.
11:30 Now, this is pretty good if you're just
11:31 looking at the visual flare of it
11:33 because obviously this is quite far
11:34 already from the normal AI vibecoded
11:37 designs that you may be used to or see.
11:39 However, even though this looks pretty
11:41 good, remember that visual flare is not
11:43 really the only thing that brands or
11:45 clients look for, especially when it
11:47 comes to these websites. Because if we
11:48 to look at Ketone IQ's actual website,
11:51 their brand design system is actually
11:53 quite different. So, I think the
11:54 gauntlet loop can still help you out
11:56 quite a lot, but if you don't start with
11:58 a really good minimum viable design or
12:01 product, then what the gauntlet loop
12:03 will do is just optimize towards
12:05 probably the wrong thing. And this is
12:07 really important to consider, especially
12:08 with powerful prompt structures like
12:10 these. Because if you notice those
12:11 gauntlet loop prompt that we ran, in
12:13 fact, any looping prompt that you run,
12:15 they usually take a lot of time and
12:16 tokens for them to finish. And so the
12:18 way that I would use them moving forward
12:20 personally is probably not to start with
12:22 them as your initial prompt. Because
12:24 what can happen there is even though the
12:26 final output that you would get looks
12:28 good, they might not actually be on
12:29 brief and might be really far from what
12:31 you want because you just let the agent
12:33 decide the direction for you. But if you
12:34 start with a really strong minimum
12:36 viable product or in this case a design
12:38 system which I've taught in previous
12:40 other tutorials in this channel and in
12:42 our community then you can just
12:43 introduce this gauntlet loop prompt as
12:45 sort of a warp drive in terms of just
12:47 sharpening or polishing the quality of
