This Claude Skill Just Fixed Loop Engineering

0:00 There's a type of loop that's been hyped up a lot lately, and it's called the gauntlet loop. It's the loop that actually does let people build huge apps and proper high-quality games, and all of it one shot. For example, we gave it a huge product to build, and while it took over an hour, it was able to complete the job without any bugs. And the prompt behind all of that is nowhere near as complex as you'd expect. But, that's the part everyone is telling you about. What they're not telling you is that this loop has two major issues, and those issues are exactly why it's fine for building games and why you can't use it on a real project. So, you'd think fixing that takes some whole new technique, but it doesn't because the fix has already been built and shipped in a way you wouldn't expect. If this is your first time, then welcome. We're a software company, and this is our channel AI labs, where we show you how to optimize your business with AI. And if you don't have your own, you can use these skills to get paid by optimizing it for someone else. And in this video, we're going over the loop, what those two problems are, and how they've already been solved. Now, if you already know what a gauntlet loop is, skip to the next section because this part is just the background. But, before going to gauntlet loop, you need to know what a loop even is. Before loops, when you build something with Claude, you're the one checking it. You send a prompt, it gives you something back, you look at it, you tell it what's wrong, and you keep doing that until it's right. A loop is when you're not in that back and forth anymore. You give the agent the goal and the standard it has to reach, and it keeps checking its own work until it gets there. You only see the result at the end. The gauntlet loop is a new kind of loop that's been going around a lot lately. People have used it to build games, 3D worlds, and full websites, all from a single prompt. But, what's behind it is a lot simpler than the results make it look because the whole method is a prompt that's only three lines long, and that's what sets the loop off. Now, this whole thing started when Matt Schumer posted a demo on X of a first-person shooter game and said Claude built it from a single prompt without using any existing assets.

1:50 That's why the post got really popular because a model producing a complete playable game in one prompt is not what people thought these models could do yet. A few days later he published how he actually built the game and also gave the method the name gauntlet loop. He could have told the agent to make the game good, but good is something it decides for itself and an agent that decides its own standard passes its own work. So he gave it a real game to measure the work against instead. And once the method was out, other people started running it themselves. Andre Karpathy, who was one of the founding members of OpenAI, said results like these matter because work this high quality was never worth producing before when it took was never worth what you got. A model doesn't have that limit. So people went ahead and experimented with different ideas that push the models boundaries to the max. But before we explore more of it, it would be great if you subscribe to the channel and hit the hype button. This small gesture of support goes a long way for us. Now let's actually understand how this loop works underneath. Schumer published the exact prompt he used and it was just three lines that built the entire game.

2:51 Each line handles a different part of the build and it's simple enough that you can write the same three lines for whatever you're making. The first line defines what you're building. Schumer's was to build a first person shooter and the second half of that line defines what quality it needed to hit, which was the level of the most recent Call of Duty games. He asked for triple A quality, which is what the industry calls its biggest budget games and he spelled out that he needed it perfect in literally everything from the textures to the physics. The second line is how it should build and this is the line that decides how the work gets split up.

3:23 You tell the main agent to break the goal into smaller parts itself and hand each part to its own sub agent. Now if you don't know what sub agents are, they're separate agents that the main agent kicks off and each one works on its own small task in its own memory without seeing what the others are doing. And the prompt is very specific about this. The agent has to split the work up by itself so that this hassle doesn't come on you. But the agent still needs to know it's going in the right direction and that's what the critic is for. The prompt puts a loop on each agent that the main one spawns and to review the work of each one, it attaches a separate sub-agent. That review sub-agent is called the critic. The critic's only job is to check the work, and if it isn't good enough, it sends it back to the builder agent to correct until it is. The critic never builds anything itself, and it starts with no memory of what came before. So, it doesn't know who made the work or how many times this part has already been sent back. It just has to be brutal and critically honest in grading the thing.

4:16 The third line is the actual quality level that the final output is supposed to match, and that's what tells a critic when it's allowed to stop. Schumer sets Call of Duty as the standard for how the game being built by the agent should look. His instruction was that the critic should literally compare the two blindly and say which one looks better. Blind here just means it isn't told which one Claude made, so it doesn't know which one is the product and which one is the game Claude designed, out of which it just picked the game which was better of the two. And there's one more word at the end of that prompt worth knowing about, which is ultra code.

4:47 That's a keyword in Claude code, and putting it in is what turns this into a dynamic workflow, which is a feature that runs a whole fleet of those sub-agents at once instead of dividing the work across just a few. And when you run the work like that, that's what we actually call a graph. Now, if you don't know what graphs are, they're basically an advanced form of loops, where a lot of different sub-agents are looping rather than one agent looping on its own, which is exactly what the gauntlet loop is doing. Now, if you've been watching our previous videos, you'll know we already covered something like this long before it got popular as the gauntlet loop. And what the gauntlet loop draws is a diamond graph, which is one task at the top splitting out into several sub-agents running side by side, and then narrowing back down into a single agent that pulls everything they found into one answer. So, the whole concept of gauntlet loop might not be a new thing for you, but the thing you don't know is that this loop's got some major problems. But before we talk about what problems, let's have a word by our sponsor. If you're learning to code, what really makes a portfolio project stand out is real data. Most beginner projects run on fake sample data. The catch is that getting real data usually means scraping and that's a headache nobody wants. That's where Serper API comes in. It gives you clean structured search results from Google, YouTube, and more in a single API call and it handles the scraping headaches for you, captures, proxies, all of it. You get millions of real data points as clean JSON and sharpen your data skills while you build. Instead of another to-do list clone, you could build a live price tracker with their Google Shopping API or a trends dashboard powered by their Google Trends API to show what's rising in real time. That's the difference between a project that looks like a tutorial and one that gets you hired.

6:24 You can start with 250 free credits. Just click the link in the description or scan the QR code on screen. And a big thanks to Serper API for sponsoring this video. Despite how many people on X and YouTube are one shotting entire projects with Gauntlet Loop, many aren't realizing the underlying problems. There are two major problems. The first is that the main agent is completely responsible for checking. It manages on its own how it spins up the critics and writes their instructions. So basically, you don't have control on the agents nor how the judgment prompt is being passed to the critics. All you gave it was a game to compare it to and past that, the prompt just says, "Be a really harsh critic and check it visually." And we've said this before on the channel, checking is something you should set more concretely rather than letting the agent verify on its own. So what it means is that the agent on its own is figuring out everything and given the scale it is working, you won't be able to figure out what caused the issue in the long run. The second problem is the one that decides whether this method works for you at all. The quality bar in that prompt is an existing product.

7:24 Schumer said it as Call of Duty, a game that already shipped. So the critic had a real thing to measure the work against instead of deciding on its own what good meant. That's the entire reason this worked and that's fine when you're building a game because there's always something you can compare it to. Same goes with a landing page that you're building or a 3D world. You name what you want to build, the critic goes and looks at it, and it picks which of the two is better. But, when you're building something new, there's no existing app to set that bar by. The critic makes up a standard and starts passing work by it. And when you realize that its assumed direction isn't what you want, you've wasted a lot of time and tokens.

7:59 So, you come back to a pile of features that all got built in one go against a standard the agent made up itself. And having nothing to compare the work to is the normal case, not the exception. If you're building the billing rules your own business runs on, there's nothing finished you can hand the critic to check it by. So, the gauntlet loop works when there's something close enough to copy, and it breaks the moment there isn't. There's a fix for this, and it comes in two parts. The first is verification, where you plan the checks properly instead of letting the agent invent them, and we covered that in the graph engineering video. The second is giving the loop concrete requirements so that it doesn't drift from what you want, and that's where a skill called wayfinder comes in. Wayfinder is made by Matt Pocock. developer who's put out a whole set of skills you can install and use, and each one is built for a different job. Wayfinder is his intensive planning one, and in his own words, it's built on the fundamentals of planning work that he learned back when he was a developer before AI existed, and it isn't tied to coding at all. You can use it for anything you need to plan out. And the reason this skill exists at all is a problem you've probably already run into. When you plan something big with an agent, the destination is clear, but the way to get there isn't, and that stretch in between is what Pocock calls the fog. The agent never tells you when it's in the fog. It fills the gap with its own assumption and carries on planning as though the thing was settled. So, what you get back is a plan that looks finished with invented parts in the middle of it. Out of that, it builds a map. Every decision that still needs making goes on to that map as its own question, and those questions get split into two groups. There are the ones you can settle right now because everything they depend on has already been decided, and the ones still in the fog because something you haven't looked into yet is holding them up. And that's the part that matters for us. When Wayfinder hits fog, it doesn't guess. It sends the agent off to go and clear the fog, and that can be done through either researching or building something rough to look at and react to, or a real-world job like signing up for a service so you can judge it. Each one of those is handled on its own, and once it's settled, the answer goes back onto the map and opens up whatever was waiting on it. You work through that map question by question until there's no fog left.

10:05 What you're left with is every decision written down with the reasoning attached to it, and Wayfinder turns all of that into a single spec, which is basically the one document that lays out what you're building and why. And that's what makes Wayfinder the fix for the gauntlet loop, because just like how Call of Duty worked as a bar for the game, a spec become the same bar and becomes a way to verify what marks the thing you want to build as done. This spec is the exact thing that clears up the planning fog problem we talked about. Every decision in there was actually settled instead of assumed. So, when you're building the billing rules for your own business or anything else with nothing to copy from, the critic still has something solid to work from instead of inventing a standard of its own. So, to actually show you how this works, let's take this HR system as an example.

10:48 People can use this to apply for leaves, file complaints, and more. Now, if you want to install the original Wayfinder, you can install it from the GitHub link below. The GitHub repo has an install command that you can run inside Claude code, but there is a problem with the original skill. Wayfinder is really extensive in how it plans, because it's built to carry you all the way through to a finished spec. That wasn't what we needed. We only wanted the part that gets you to clarity so that we'd come out of it with a complete plan and nothing else. When you run the original Wayfinder skill, it takes every decision you made during the questioning session and turns each one into a separate requirement file the agent can refer back to. It defined what to build, but what we wanted was a key the agent could check itself against. So, we asked Claude to the skill so that instead of writing a separate file for every decision, it turns those decisions into a single answer key the agent can keep checking itself against. It rewrote the skill entirely, kept the main parts of the original, and shaped the rest around the different goal. What we ended up with is a much simpler version, one that only writes two files, the map and the answer key, instead of the separate tickets the original produces. But, here is another interesting thing. The Wayfinder skill doesn't work by itself.

11:59 It calls other skills from Matt Pocock as well. But, in our version we've also reduced that. You just need these three skills so you can get these from the GitHub link below as well. For example, the Wayfinder skill uses Grill Me for the questioning part of the planning process. To use it, we opened Claude code and ran the Wayfinder command because this is one of those skills the agent won't start on its own. Then, we told it what we wanted, which was that HR system, and it started questioning us. It asked who the app was actually for, what had to be in it, and what didn't, then what done was supposed to look like, and what could go wrong once people were using it. It was a long back and forth that ended at 34 questions.

12:34 Once we'd answered all of them, it closed the interview and wrote two files into a.wayfinder folder. The first is the map, which holds every decision we made, the reason behind each one, and what the finished thing is supposed to look like. The second is the answer key, and that one is nothing but checks, where every line comes back as either a pass or a fail. So, to actually start the gauntlet loop, we needed a prompt. We copied the exact one Matt posted and gave it to Claude. Then, you ask it to rewrite that prompt for the app you're building, which in our case was the HR system. The one thing you change is what it measures against. Instead of a game, you tell it the source of truth is the .wayfinder folder that came out of the planning, and everything gets checked by what's in there, exactly the way Call of Duty worked in the original. And, Claude hands the whole thing back in the same gauntlet loop format, just written for your app. From there, it ran the same way the original does. It planned out the sub agents, except this time they had the answer key to check everything by. We told it there was no close enough and no shortcuts. It planned what it was going to build first, then the tools it needed to install, then the foundation work so the agents had something solid to build on. After that, it launched a lot of agents at once, each one on a different part of the system. The build took 1 hour and 33 minutes and it went through about 40% of our session limit.

13:47 And if we'd been running it on the API instead of our max plan, that same build would have cost around $116, which is a lot. But what came out the other side was the app just like how we'd planned it. Every feature we wanted was working correctly in the app. Though it did have some issues, but overall it was the closest to what kind of implementation we needed. The skill we created for this one, along with all the other resources, are available in AI Labs Pro, which is our community. So if you found value in what we do and want to support the channel, this is the best way to do it. The link's in description.

14:18 That brings us to the end of this video. If you'd like to support the channel and help us keep making videos like this, you can do so by using the super thanks button below. As always, thank you for watching and I'll see you in the next one.