This NEW Claude Prompting Technique is blowing people's minds (gauntlet-loop)

The wow demo (0:00)

The kind of build people reacted toa detailed, playable 3D kart racer with textured environments, one of many made by pointing the gauntlet loop at a game. The rest of the video is how the prompt behind these works and where it fits beyond games. 0:08

Where this came from (0:43)

The technique was popularized by Matt Shumer, who posted a demo on X claiming Claude Opus 5 one-shotted a full first-person-shooter-quality game with "not a single external asset", all custom code. He named the technique the gauntlet loop and published a write-up.

Matt Shumer on X"It's real, driven by a technique I'm calling the Gauntlet Loop. Here's how to run one. It works for far more than games." The quoted post reads "Claude Opus 5 one-shotted this game. EVERYTHING you see in this demo is custom code... not a single external asset was used." 0:43

People then reused the pattern to build other high-fidelity games (a Pokemon-style 3D area, car racers, a Mario-Kart-style game).

One of the community buildsa kart racer with detailed textures and environments, from Matt Shumer's "best game I've seen built with a Gauntlet Loop" post. 1:36

Why Karpathy says this matters (2:25)

Andrej Karpathy framed why these hyper-custom builds are a meaningful signal, not just a party trick. In a post, he said we are leaving the era where you test an LLM with something like "draw an SVG of a pelican on a bicycle", and described giving Opus 5 the first paragraph of Lord of the Rings, a ~1M-token budget (~$10), and asking for a Three.js render, which ran ~2 hours and produced ~5,500 lines of code that procedurally rendered the scene.

Karpathy"We're starting to leave the territory where you'd test an LLM by e.g. 'create an svg of pelican on a bicycle'." His point (paraphrased from the post): no one would hand-write something this custom, but LLMs have "all the stamina and patience in the world", so hyper-custom worlds are a new capability worth paying attention to. 2:25

The gauntlet loop prompt, broken down (3:02)

The full prompt Matt Shumer shared is only three lines / three sentences. What matters is the STRUCTURE, not the exact words.

The verbatim prompt"I want you to build a first-person shooter at the level of the most recent Call of Duty games. It should be utterly perfect, visually beautiful, with every single thing done at AAA quality, from textures to physics to anything you could think of. Fan out sub-agents and have sub-agents tackle each one individually so that the game is utterly perfect. You should /loop on each item and have a separate sub-agent check it visually to ensure it looks triple A. That separate sub-agent should be a really harsh critic, and if it doesn't look triple A, it should keep going. Don't stop until each sub-agent is utterly wowed with the quality when compared with the actual Call of Duty game. It should literally compare them side by side blind and say which one looks better. Do this in ThreeJS. /loop until it's utterly perfect. Fan out sub-agents and ultracode." 3:12

The reusable skeletonline 1 = The Task (What), line 2 = The Build Method (How), line 3 = The Bar to hit (When to stop). Copy this shape for any build. 3:55

Sub-agent orchestration in 3 levels (4:33)

The presenter frames the whole idea as three levels of who does the verifying.

Level 1, normal prompting: the agent works, you (the human) verify, then re-prompt until it is right. Most common, most manual. 4:40

Level 2, a normal loop: a second agent takes the verifier role. The builder and a critic agent talk to each other until a bar is met, and only the passing result comes back to you. 5:05

Level 3, the gauntlet loop: the main agent orchestrates a whole TEAM. It fans out multiple builder sub-agents, each paired with its own critic sub-agent, all looping to the bar before the final result comes back. This is the level the gauntlet loop operates at. 6:02

Anthropic called this back in 2024 (4:50)

The verifier idea is not new. Anthropic's 2024 article "Building Effective Agents" documents the evaluator-optimizer workflow: one LLM call generates a response while another provides evaluation and feedback in a loop, which generally produces better output than a single model grading its own work (models tend to convince themselves their output is already good enough).

anthropic.com/engineering/building-effective-agents, the evaluator-optimizer workflow: Generator produces a Solution, Evaluator either Accepts (out) or returns Rejected + Feedback (loop). The gauntlet loop is this pattern taken to the extreme, across a fleet. 5:15

Test 1: a real 3D apartment walkthrough (7:34)

The presenter applied the pattern beyond games: build an explorable 3D walkthrough of a real Sydney apartment listing, from its floor plan and reference photos.

The input pegthe real listing floor plan (plus 13 reference room photos fed alongside it). 7:38

The prompt keeps the exact skeletonthe bar is the listing photos plus the floor plan; break the goal into the smallest pieces; fan out sub-agents; each has a separate fresh-context critic that screenshots the scene from the same camera angle as the matching photo and compares them blind, side by side; the critic names the single biggest remaining gap and sends it back; don't stop until the critic picks the render as the real photo or genuinely can't tell. Model: Opus 5. 8:05

The live workflow viewphases (Lighting, Rooms, Critique, Progress), 7 room-builder sub-agents fanned out, each with a blind critic that sees the render and the real photo as an unlabelled A/B and passes only if it picks wrong or can't tell. Round 2 was FAIL on all five judged rooms, every critic picking the render in under two seconds. 8:30

Claude generated its own live progress page: "Explorable 3D walkthrough VS the real listing photos. Every piece below is built by one agent and judged by a separate critic that compares the render against the real photograph blind. A piece is only done when the critic cannot pick the render." Stats: 1 piece won, 11 pieces, 12 critic rounds run. 8:55

The result after stopping it early (it was still iterating): an explorable 3D apartment with a room menu (Living, Dining, Kitchen, Entry hall, Balcony, bedrooms) and WASD controls. The marble kitchen island and layout closely match the reference photos; textures would keep improving with more time. 9:20

Test 2: a product landing page (10:35)

The same pattern was applied to a front-end landing page for the Ketone IQ product.

The build again fanned out sub-agents with a judging phase (evaluator agents checking the worker agents, including research agents to verify the numbers). Note the cost: the closing workflow alone shows 7 agents and ~853.6k tokens, and the run took about 1h19m. 10:35

The outputa polished dark-mode page with a headline, data cards, and animations, well beyond typical vibe-coded output. But it is off-brand. The real Ketone IQ site uses a different, lighter design system, so visual flare alone missed what a client actually needs. 11:00

Where the gauntlet loop can go wrong (11:30)

This is the most important lesson. Looping prompts take a lot of time and tokens, and they optimize hard toward whatever direction you gave them. If you start from a blank prompt and let the agent decide the direction, the polished result can be far off-brief. The recommended way to use it: start from a strong minimum viable product or design system, then run the gauntlet loop as a "warp drive" to sharpen that MVP into a v2 that is both high quality and on-brief.

The two paths. Top: prompt straight into /gauntlet-loop, get a slick but off-brand result. Bottom: build (or supply) an MVP / design system first, then run /gauntlet-loop to polish it, staying on-brief. 12:40

The presenter also released a /gauntlet-loop skill that generates a gauntlet-loop prompt for any task you give it (link in the video description).

Tools and resources

Claims to verify

• View counts. Narration says the origin demo hit "4.8 million views", but the on-screen post reads "3.8M views". The claimed "87 million views" for Matt Shumer's earlier "something big is happening" article is implausible for an article and is unverified; treat both view figures as marketing, not fact.
• "One-shotted" with no external assets. The claim that Opus 5 produced the FPS-quality game in a single shot with zero external assets is Matt Shumer's, shown via a demo video, not independently reproduced here.
• Anthropic evaluator-optimizer date. The article and diagram are confirmed on-screen at anthropic.com/engineering/building-effective-agents; the "2024" publication date is the narrator's claim (consistent with Anthropic's known publication timing) and is not separately verified in the video.
• Karpathy's numbers. "~1M token budget (~$10)", "~2 hours", "5,500 lines of code" are quoted from Karpathy's post as shown on screen, not measured here.
• Token/time cost of the demos. "~853.6k tokens / 7 agents / 1h19m" (landing page) and "~2 hours" (apartment) are read off the on-screen panels for those specific runs and will vary widely by task.

Glossary

• gauntlet loop: a 3-part prompt pattern (extreme-quality task + fan out sub-agents each with a critic + a high stop bar) that makes an agent self-verify through many loops.
• sub-agent: a secondary agent the main agent spawns to handle one piece of the work independently.
• fan out: to split a goal into pieces and launch a separate sub-agent for each in parallel.
• critic (critic agent / evaluator): a sub-agent whose only job is to judge another agent's output against a standard and send it back if it falls short.
• evaluator-optimizer: Anthropic's named workflow where one LLM generates and another evaluates in a loop until the output is accepted.
• orchestration: the main agent coordinating multiple sub-agents rather than doing all the work itself.
• loop / /loop: repeating build-then-check until a stop condition is met; in the prompt it is written as a literal instruction.
• stop bar (the bar to hit): the explicit condition that tells the loop when it is allowed to stop (e.g. "until the critic can't tell the render from the real photo").
• blind A/B: showing the critic two unlabelled options (render vs real photo) so it cannot be biased by knowing which is which.
• one-shot: producing a complete result from a single prompt with no manual follow-ups.
• Opus 5: the Claude model used in the demos.
• Three.js: a JavaScript library for rendering 3D graphics in the browser.
• ultracode: a keyword used at the end of the prompt to signal maximum-effort coding (used verbatim in Matt Shumer's prompt).
• AAA / triple-A: game-industry shorthand for the highest production quality; used as the quality bar in the prompt.
• MVP (minimum viable product): the smallest working version of a build; here, the on-brief starting point you should give the loop to polish.
• design system: the defined set of brand styles (colors, type, components) that keeps output on-brand.
• on-brief: matching the actual requirements/brand, as opposed to merely looking good.
• token budget: the cap on tokens (and therefore cost/time) a run is allowed to consume; looping prompts consume a lot.