Most people still babysit their AI. Write a prompt, read the answer, write another prompt, repeat, for hours. You watch the cursor blink, you nudge it back on track, you correct the same small mistake three times in a row. There’s a different way going around right now, and builders like Claude Code creator Boris Cherny and engineering lead Addy Osmani are all pointing at the same thing: give the AI a goal, a harsh critic, and a stop condition, then walk away.
The Key Idea
Instead of steering every single step, you set up the destination once. The AI checks its own work, decides what’s wrong, and prompts itself into the next attempt. No human in the loop between messages. Some of these sessions run for 60+ hours straight, chugging through builds, tests, and rewrites while the person who started it sleeps, eats, or works on something else entirely. The shift isn’t really about the AI getting smarter overnight. It’s about handing over the loop itself, not just the individual task.
Old Way vs New Way
The old workflow: you write a prompt, AI responds, you inspect it, you write another prompt. Repeat until you’re tired of typing. Every improvement depends on you noticing what’s wrong and describing it well enough for the model to fix it. If you step away for an hour, progress stops for an hour.
The new workflow: you define the goal, what success looks like, and the guardrails. The AI works, tests itself, and keeps going without waiting for your next message. With the right agentic tools it can also:
- 🧩 Spawn specialized subagents for different parts of the job, so one part handles UI while another handles backend logic
- 🧪 Run code and tests on its own, catching regressions before they pile up
- 👀 Inspect screenshots and finished work, comparing what it built against what it was supposed to build
- 📝 Record what it already tried, so it doesn’t repeat mistakes across attempt 40 and attempt 41
The community is calling this loop engineering, and it turns AI from a tool you constantly operate into something that works toward an outcome on its own. The practical difference shows up in how much of your day it eats. Step-by-step prompting demands your attention in short, constant bursts. Loop engineering front-loads the thinking into setup, then gets out of your way.
The Extreme Version: The Gauntlet Loop
Matt Shumer pushed this idea to its limit. One prompt: build a Call of Duty style shooter in Three.js, split the work across subagents, compare every piece against the real game, and keep improving whatever loses that comparison.
The run went for over 100 hours, spun up a fleet of subagents, and produced roughly 55,000 lines of code. Shumer calls it the Gauntlet Loop, and the name fits: every piece of the project has to survive a comparison against something genuinely good, over and over, until it either holds up or gets sent back for another pass.
Here’s the flow:
- A lead agent gets an ambitious goal plus a real quality reference
- It splits the project into parts that can be improved separately, like movement, combat, level geometry, and enemy AI
- Builder agents create those parts, each one focused on a narrow slice of the whole
- Fresh critic agents inspect the actual result against the reference, not against what the builder claims it did
- If the reference still wins, the critic flags the biggest gap and sends it back for another round
The game never actually beat Call of Duty. That’s not the point. Call of Duty was the quality bar that stopped the agent from settling for “pretty good for AI.” Without that bar, the run would have declared victory on something mediocre a hundred hours earlier.
How to Try This Yourself
You don’t need a custom framework or a pile of automation scripts. If you’re working in a capable agentic environment like Claude Code or Codex, with file access, tools, and subagents, you can:
- Pick one ambitious goal and one real reference to measure against, something concrete enough that “better” or “worse” is obvious
- Write down what success actually looks like, in concrete terms, not vibes
- Set your operating limits (time, budget, scope) so the loop knows when to stop, not just where to aim
- Hand it over and let the agent orchestrate builders and critics itself
- Check in periodically instead of every single step, maybe once an hour instead of once a minute
Start small if this is new to you. A single feature with a clear reference implementation is a better first test than an entire app. One thing worth watching: this burns a lot more tokens than step-by-step prompting, since every critic pass and every rebuild adds up. Worth it if the goal is big enough to justify the run, less so for a quick script you’ll throw away tomorrow.
Try It
Pick a project you’ve been chipping away at manually. Give it a real reference to beat, a clear stop condition, and let the loop run instead of steering every message yourself. That’s the whole shift!
Frequently Asked Questions
Q: This sounds expensive. How does token consumption compare to normal prompting?
Much higher, especially over 100+ hours. The Gauntlet Loop generates multiple critic rounds, iteration cycles, and agent spawning across many hours. For simple tasks or quick edits, step-by-step prompting is cheaper and faster. Reserve Gauntlet for ambitious, multi-faceted projects where you have the budget and want autonomous iteration.
Q: What keeps the loop from spinning out of control forever?
Without proper guardrails, it can spiral. The critic can theoretically invent new deficiencies at every round, creating a moving goalpost. Real Gauntlet loops need explicit controls: iteration caps, cost ceilings, plateau detection, fixed success criteria, and human approval gates before changing goals. Without these safeguards, you might end up with 100+ hours of agent runs and unclear ROI.
Q: When should I actually use Gauntlet vs. regular prompting?
Use Gauntlet for complex, exploratory projects where you want hands-off multi-hour iteration and have the token budget. Use regular prompting for quick edits, simple tasks, tight feedback loops, or cost-sensitive work. Ask yourself: is this a moonshot needing overnight iteration, or do you need tight feedback cycles?
The “Gauntlet Loop”: give AI a clear goal, a harsh critic and a stop condition then let it build and improve for hours
by u/ThePromptIndex in ChatGPTPromptGenius