Jonathon's AI Wiki

The Gauntlet Loop (Matt Shumer)

9 min read

Source: ai-research/shumer-gauntlet-loop-original-2026-07-29.md (primary — Shumer’s own guide at somethingbig.ai/gauntlet-loop, 2026-07-27, plus his verbatim X announcement thread) and raw/reddit-1v9m76g.md (community reproduction)

Primary author: Matt Shumer (@mattshumer_) | URL: https://somethingbig.ai/gauntlet-loop | Published: 2026-07-27

Reproduction — Author: u/BoneShaman | URL: https://www.reddit.com/r/ClaudeAI/comments/1v9m76g/ | Posted: 2026-07-29 | Score: 157

The Gauntlet Loop is Matt Shumer’s name for the prompting method behind “Claude of Duty” — a Call of Duty-style FPS that Claude Code with Opus 5 built from a single prompt (~55,000 lines of code, every asset generated in code, 3.8M views, repo open-sourced at github.com/mshumer/Claude-of-Duty). The core mechanic: the agent breaks the goal into parts, gives each part a specialist builder and a ruthless blind-critic subagent, and only passes work that beats a real-world reference in a blind side-by-side comparison. The r/ClaudeAI reproduction covered here (“Claude Bandicoot”) swapped the target to a Crash Bandicoot-style 3D platformer and ran the same prompt structure across three 5-hour Opus 5 ultracode windows.

Key Takeaways

  • The loop in one sentence (Shumer’s own): “The agent (not you!!) breaks the goal into parts, gives each part a specialist builder and a ruthless blind critic sub-agent, with a mandate to only pass if the generated artifact is better than some real-world equivalent.”
  • The bar is the load-bearing part. “Make it amazing” is not a bar; actual Call of Duty screenshots are. The bar does not need to be reachable — Claude of Duty never beat Call of Duty — it exists to give direction and to stop the agent from settling when output looks merely “pretty good for AI.”
  • Never let the builder grade itself. The critic is a fresh-context subagent given the goal, bar, and actual artifact — never the builder’s history or self-summary — and behaves like a blind A/B tester on the real pixels/output.
  • No fixed round count. Keep looping until the output wins or you stop the run; Shumer stopped Claude of Duty while it was still improving. Claude Code’s /loop skill implements the repetition, but the principle is “no arbitrary final round.”
  • It requires a real agentic harness (Claude Code or Codex — file access, rendering, screenshots, subagents), and Shumer recommends ultracode effort (/effort → ultracode) for serious runs, which “costs much more.”
  • Reproduction cost anecdote: the Claude Bandicoot run consumed three 5-hour Opus 5 ultracode windows plus a few manual cleanup prompts, and the author judged it “would continue to improve” when he stopped.
  • It generalizes past games, per Shumer: websites, writing (reference paragraphs as the bar), backend engineering (test suites, latency targets as the bar) — anything where output can be inspected and compared.

The Loop, Step by Step

From the primary guide:

  1. Give the goal, not the implementation. State the destination (“AAA-quality FPS in Three.js”) without architecture, workstreams, or steps — prescribing them “replaces the model’s judgment with your own.”
  2. Give a real bar. A concrete, inspectable reference: game screenshots, best-in-category websites, exemplar paragraphs, a test suite. If no bar is known, make finding one part of the task.
  3. Let the agent split the work. The lead agent decomposes the goal into the smallest pieces improvable and judgeable separately (the gun, the lighting, one tree), and decides what runs in parallel.
  4. Builder + fresh-context critic per piece. Separate subagents. The critic does a blind side-by-side against the reference, picks the winner, and — when the reference wins — names the single biggest remaining gap and sends the piece back.
  5. Keep looping. No fixed number of rounds; stop when you like the result, improvements stop mattering, or the compute budget runs out.
  6. Watch without interrupting (optional): have the agent maintain a live HTML/workbench progress page with screenshots and drafts, so you can check from your phone instead of breaking the run to ask for status.
  7. Smoothing pass (optional): after each major wave, one fresh agent inspects the whole artifact and reconciles independently-improved pieces so the result feels like one thing.

Shumer distills the core as: split, build, judge, repeat.

The Verbatim Prompt (Claude Bandicoot adaptation)

From the Reddit reproduction, verbatim — including the /goal and /loop commands on their own lines:

/goal

 I want you to build a 3D platformer Claude Bandicoot at the level of the Crash Bandicoot game. 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 Crash Bandicoot 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.

This is a near-verbatim adaptation of Shumer’s original Claude of Duty prompt (archived in the primary source), with “first-person shooter / most recent Call of Duty games” swapped for “3D platformer Claude Bandicoot / the Crash Bandicoot game” and a /goal prefix added. Shumer also published a meta-prompt (in the primary source) that generates a domain-appropriate Gauntlet Loop prompt — including choosing the bar — for any goal.

Where It Sits in the Loop Taxonomy

  • In Anthropic’s trigger taxonomy (proactive), this is a goal loop — with nested per-item inner loops spawned by the agent’s own decomposition.
  • It is a verifier-in-the-loop pattern: the wiki’s Verifier-First Loops discipline says a loop is only as good as its verifier. The Gauntlet Loop’s contribution is a verifier design for domains with no programmatic check — subjective visual/creative quality — built from three parts: a fresh-context critic (no builder contamination), a real-world reference artifact as ground truth, and a blind A/B protocol instead of a rubric score.
  • The “mandate to only pass if better than a real-world equivalent” converts a vague quality goal into a falsifiable per-piece comparison — the same move a test suite makes for code, applied to pixels.
  • It differs from review-gated loops like Looper in that the human is removed from the gate: the critic subagent holds the bar, and the human only chooses when to stop paying.
  • Alongside the loop catalogs (Forward Future’s Loop Library, Berman’s trigger-x-goal catalog), it slots in as a named community pattern: adversarial-critic quality loop with reference-anchored termination.
  • Community synonym: one replier to Shumer’s thread had independently named the same idea “benchmark-loop” (github.com/martbln/benchmark-loop).

Cost and Session Anecdotes

  • Claude of Duty (Shumer): one prompt, many hours unattended, ~55,000 lines of code, all textures/meshes/animations/sounds generated in code, run on Claude Code + Opus 5 with ultracode; stopped while still improving. Built two days after the Opus 5 launch (2026-07-24); demo posted 2026-07-25, method named and guide published 2026-07-27.
  • Claude Bandicoot (u/BoneShaman): three 5-hour Opus 5 ultracode windows, plus “a few prompts of clean up to tie it up at the end”; the author was satisfied but believed it “would continue to improve.”
  • Shumer’s guide is explicit that ultracode “costs much more” — the bar-that-never-passes design means the loop spends compute until the human stops it, so the budget IS the stop condition in practice.
  • Practitioner note from the thread replies: one user reported needing “a clean cc instance with no agents.md to see results” — pre-existing project instructions can interfere with the loop’s behavior.

Caveats

  • Both the original and the reproduction are community demonstrations, not controlled evaluations; the evidence of output quality in each case is a video demo (and, for Claude of Duty, an open-source repo), not independent review or playtesting.
  • The Bandicoot reproduction scored 157 on r/ClaudeAI — a modest signal compared to the 3.8M-view original; its final quality relative to Claude of Duty is not assessed anywhere in the sources.
  • “Blind” comparison is only as blind as the harness makes it: the critic is a subagent of the same model comparing its team’s render against reference imagery, and the sources do not document how reference screenshots were supplied or whether position/order randomization actually occurred.
  • The one-shot framing has soft edges even in the primary: Shumer did not steer mid-run, but the reproduction needed manual cleanup prompts at the end, and stopping “when you like it” reintroduces human judgment as the real terminator.
  • ultracode is an effort setting surfaced via /effort per the primary source; expect it to be expensive and to interact with 5-hour usage windows as in the reproduction.

Try It

  1. Pick a goal with inspectable output and choose a concrete real-world bar (screenshots, exemplar sites, reference prose, a test suite) — or make bar-finding the agent’s first task.
  2. Run inside Claude Code with Opus 5; consider /effort → ultracode for a serious attempt, with a budget cap decided up front.
  3. Adapt the verbatim prompt above (swap domain and reference), or paste Shumer’s meta-prompt from ai-research/shumer-gauntlet-loop-original-2026-07-29.md into a strong model to generate a tailored one.
  4. Keep the prompt minimal: goal + bar + builder/critic mandate + keep-looping. Do not prescribe architecture or decomposition.
  5. Ask the agent to maintain a live progress page, then leave it alone; stop the run when improvements stop mattering or the budget is spent, and finish with a smoothing/cleanup pass.
  6. If results disappoint, try a clean instance without a project AGENTS.md/CLAUDE.md, per the thread’s practitioner note.

Open Questions

  • How is the reference bar physically supplied to the critic (screenshots in context, fetched images, model memory of the game), and does the blind A/B protocol actually randomize which side is which?
  • Dollar cost is unstated in both sources — what do ~15 hours of Opus 5 ultracode windows or Shumer’s “many hours” run actually cost?
  • How much of Claude of Duty’s quality gap over typical Opus 5 demos is the loop versus ultracode effort versus run length? No ablation exists.
  • Shumer promised non-game demonstrations (he mentions a Gauntlet Loop writing a full horror novel) “in the coming days” — worth tracking whether the pattern holds outside visually-inspectable domains.
  • Does the loop hold up on Fable 5 or lower effort settings, where the economics differ?

Graph View

Backlinks