Gauntlet Loop: A Claude Code Skill That Turns a Goal Into a Blind-Comparison Prompt
Turn any goal into a short prompt that makes your agent set a real quality bar, run builder and critic pairs, compare blind, and loop until it wins.
At a glance
- What is it?
- Gauntlet Loop packages Matt Shumer's builder-versus-critic technique as a single SKILL.md file. It writes the prompt; a fresh agent session runs the loop. Here is what the repository actually documents, and where the design leaves gaps.
- Who is it for?
- Adopt Gauntlet Loop if you already run agents and your output keeps landing at good enough, and you are willing to supply a named, fetchable reference and a fresh critic session. Skip it if your goal has no public artifact to compare against, or if you want a per-round score rather than a binary pick.
- Can I use it commercially?
- Yes, with credit. CC-BY-4.0 allows commercial use as long as you credit the authors and indicate what you changed. It is written for creative content, so check how it applies to any code.
- Is it still maintained?
- Yes. The repository last received commits 42 days ago.
- What is it written in?
- GitHub does not report a main language for this repository.
Answers come from the project's GitHub data, last synced on September 16, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem Gauntlet Loop addresses
Agent output tends to stop at the first version that looks finished. The README frames this directly: most agent output stops at good enough because nothing is holding it to a standard. The skill exists to supply that standard in a form the agent cannot argue with.
The audience is narrow and specific. You need an agent that supports skills, a goal that produces a tangible artifact (a page, an essay, a CLI, a research brief), and a public reference that is genuinely better than what you can produce today. If any of those three is missing, the technique degrades rather than fails loudly.
It is also, by the author's own framing, not an original idea. The repository states that the gauntlet loop is Matt Shumer's technique, written and named while he built Claude of Duty, and that this repo packages that pattern as a reusable skill. The credit section repeats it: this repo is not the technique.
How the bar, the critic and the blind pick fit together
The mechanism has four stages, and the README numbers them. You give a goal. The skill offers two or three quality bars. You pick one. It writes one short prompt, around 150 words, and stops. You paste that prompt into a fresh session, where an agent splits the work, runs builder and critic pairs, and loops.
The important design choice is what counts as a bar. The README contrasts a bar with a rubric: a rubric asks the agent to grade itself against words it wrote, while a bar forces a comparison against something that already exists. Before writing anything, the skill checks three properties. The bar must be named (a specific thing, not a category), fetchable (the critic can screenshot it, read it, run it, or open it), and comparable (both can sit side by side and a judge can pick one).
The critic is where the loop gets its teeth. It runs as a separate agent with fresh context, opens the actual output, places the work next to the bar with the labels stripped, and says which is better. The README is explicit that the verdict is a pick, not a score out of 10, because a score drifts upward every round. Exit is winning the blind comparison or you stopping the run, never a fixed round count.
Installing the skill and running a first goal
There is no package registry entry here. Installation is a clone and a copy, and the repository layout confirms it: the top level holds .claude/, LICENSE, README.md and assets/, and the skill itself is one file at .claude/skills/gauntlet-loop/SKILL.md.
Clone the repository first.
git clone https://github.com/robonuggets/gauntlet-loopThen copy the skill folder into your project's .claude/skills directory. The README gives this exact command shape.
cp -r gauntlet-loop/.claude/skills/gauntlet-loop your-project/.claude/skills/After that, invoke it from your agent with a goal. The README's first example is a pricing page.
/gauntlet-loop build me a pricing page for my SaaSWhat you should see next is not code. The skill offers you two or three quality bars, each a named and fetchable thing. You pick one, and it returns a single prompt of roughly 150 words. That prompt is the deliverable; you paste it into a fresh session, and the builder and critic pairs run there.
The failure the README warns about most
A vague bar is the dominant failure mode, and the README says so twice. When the bar is vague, the critic invents the comparison and approves everything. The three checks (named, fetchable, comparable) are the guard, but they are checks the skill performs, not guarantees about your input. If you ask for something with no public analogue, you can still end up with a bar that reads specific and is not.
The second failure is builder self-judging. The critic needs fresh context and no knowledge of how hard the builder tried, so running the critique inside the same session that produced the work defeats the design. The third is a soft critic: give it a binary job, not a score. The fourth is a fixed round count, which converts the loop into a bounded retry and removes the winning condition.
There is also a structural limit worth naming. The loop has no stopping guarantee other than victory or your intervention, and the README states exactly that. Budget is unbounded by design. If you need a predictable number of iterations or a hard cost ceiling, this is the wrong tool, because the exit condition it offers is the one you are trying to avoid.
Claude Code versus other agents
The skill is written for Claude Code and depends on two features there. /loop reruns a prompt until you stop it, and ultracode opts a turn into multi-agent orchestration. The README lists both by name and treats them as the default path.
Portability is handled by substitution rather than by configuration. For any other agent, the skill swaps those two lines for plain instructions: keep looping until the critic picks ours, and run the builders and critics as parallel subagents. The README states the structure is identical. That is a reasonable claim, since the loop and the parallelism are the only two things the Claude Code features provide, but it means the reliability of the loop now rests on your agent's willingness to follow a standing instruction rather than on a runtime feature that enforces it. That is a real difference in guarantees, even though the README presents the two paths as equivalent.
A related search phrase, gauntlet loop codex, maps to exactly this case: an agent other than Claude Code running the substituted instructions.
Where this sits against a plain evaluator loop
The closest alternative is the evaluator pattern Anthropic describes in its engineering blog on building effective agents, which the README links as related reading and identifies as the pattern the loop is built on. The difference is what the evaluator compares against. A generic evaluator loop asks a model to judge output against criteria, usually expressed in words, and often returns a score or a pass or fail. Gauntlet Loop replaces the criteria with an external artifact and replaces the score with a forced choice between two labeled-stripped options.
That shift buys resistance to grade inflation, which the README calls out as the reason for a pick over a score. It costs generality. An evaluator loop works on anything a model can read, including goals with no public counterpart. Gauntlet Loop needs a fetchable reference, so a private internal tool with no comparable public implementation is a poor fit. The trade is deliberate: less coverage, less drift.
Licence and upkeep
The repository is licensed CC BY 4.0, and the LICENSE file sits at the top level alongside README.md, .claude/ and assets/. The README states free to use with attribution, and the credit section names two parties: skill by Jay E at RoboNuggets, technique by Matt Shumer. If you redistribute the skill or a derivative, those attributions are the condition the licence attaches to. That is a description of the licence text, not legal advice; read CC BY 4.0 yourself if attribution scope matters to your use.
Upgrade cost is close to zero in the mechanical sense. The whole skill is one file, SKILL.md, so updating means replacing that file. The last push to the repository was on 2026-08-05, and there are no retrieved releases, so there is no versioned artifact to pin and no changelog to diff. You are tracking the main branch by hand. The practical risk is not a broken upgrade path; it is that the prompt this skill emits is tuned to a technique owned by someone else, and the README points to the original prompt in Matt Shumer's Claude of Duty repository as the source of every idea underneath the skill.
Editorial conclusion
Adopt Gauntlet Loop if you already run agents and your output keeps landing at good enough, and you are willing to supply a named, fetchable reference and a fresh critic session. Skip it if your goal has no public artifact to compare against, or if you want a per-round score rather than a binary pick. Before you commit, verify two things yourself: that the bar you choose is something the critic can actually open, and that your agent's loop mechanism exists, since /loop and ultracode are Claude Code features and other agents need the plain-instruction substitution the README describes.
Frequently asked questions
What is Gauntlet Loop AI?
It is a skill that turns a goal into a short prompt of around 150 words, which then makes an agent set a quality bar, run builder and critic pairs, and loop until the work wins a blind comparison. The README credits the underlying technique to Matt Shumer and describes this repository as a packaging of that pattern.
What is gauntlet loop?
In this repository the term names a loop that exits when your work beats a named, fetchable reference in a blind comparison run by a separate critic agent, or when you stop the run. The README states the exit is never a fixed number of rounds.
What does the phrase running the gauntlet mean?
The repository does not explain the phrase. It only uses gauntlet as the name of the technique, which the README attributes to Matt Shumer, who named it while building Claude of Duty.
What does gauntlet mean?
The README does not define the word. It uses gauntlet only as the name of the loop technique it packages, and points to Matt Shumer's original prompt as the source of the naming.
What is the military use of run the gauntlet?
The repository does not cover the military history of the phrase. Its only use of gauntlet is as the name of an agent prompting technique credited to Matt Shumer.
Community notes