Stop Prompting Claude. Start Loop Engineering.

[00:00:00]Boris Cherny, the creator of Claude code, just said something that should change how you use AI forever. He said, "I don't prompt Claude anymore. My job is to write loops." Then I found a tweet from Peter Steinberg, the creator of Open Claude, saying the exact same thing. You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents. There's endless AI hype out there, but when two people who literally build the tools that we're using tell you to stop prompting and start building loops, I listen. So, I went deep on loop engineering and realized something. It's actually really simple. Most people just overcomplicate it. So, in this video, I'm breaking loop engineering down into three parts. Part one, what a loop actually is and when to use them. Part two, the four things every successful loop needs. And part three, the most important part, how you will build your first loop today, even if you have no technical experience. So, part one, what actually is a loop and how does it compare to a normal prompt?

[00:00:49]Unlike a normal prompt, which runs once and then stops, a loop is a prompt that runs over and over again until a specific task or goal is complete.

[00:00:58]Listen to how Boris thinks about his day-to-day now.

[00:01:00]>> Now, what's actually leveled up, I think again, to the next level of abstraction, where I don't prompt Claude anymore. I have loops that are running. They're the ones that are prompting Claude and kind of figuring out what to do. My job is to write loops.

[00:01:11]>> So, it's clear. Instead of prompting Claude 100 times to complete a task, you should now be thinking about how to create loops to accomplish clear goals.

[00:01:18]This sounds great, but when should you actually use it? Well, there's a four-condition test that I run when determining if I should create a loop or not. The first condition is, does the task repeat? For any one-time task, just use a prompt. Second is, is there a clear definition of done? When I was the COO of a $25 million tech startup, whatever task we were doing, we wanted to have a clear definition of how we would quantify if the task was done. And a lot like humans doing tasks, the most successful loops have a clear definition of done and a way to verify the results.

[00:01:46]Now, this is an art and not necessarily a science, and we'll cover that in a bit. Three is, can you afford to be wasteful? So, loops will automatically prompt itself until a task is complete.

[00:01:55]So, it can use a lot of tokens. Now, there's ways to limit this, which we will cover, but if you're always running into token limit issues, you want to be a bit more strategic using this. And four is, does the loop have all the necessary tools to complete a task? For example, if you're making a website, does it have the ability to check that the website is live and accessible to anyone? These tools will be used in the verification and the implementation process. If the answer is yes to all four of these conditions, you now have a candidate for building a loop. Here is a prompt to audit your workspace and rank your loop candidates using this four condition test. The prompt's on screen, and you know what loops are, and you conceptually understand when to use them. But, how do you build a loop that actually works? Part two is the four building blocks for successful loops.

[00:02:37]The first block is the trigger. This is what starts your loop. Every loop needs a trigger. This is the thing that kicks it off. And there are a lot of ways to set this up, but these are the three simplest ways. The first is actually {slash} loop. If you type {slash} loop into Claude, it will let you automatically run something at a set interval. For example, {slash} loop every six hours, check today's weather and notify me if I need to change my plans based on my calendar. This is nice because it's very simple, but it's running on your local machine. So, if you close your laptop, it'll just stop.

[00:03:04]The second is {slash} schedule. This lets you run something automatically in the cloud at any time or day in whatever cadence you want. So, you can run the prompt that I had just mentioned for the loops, but instead have it run at 8:00 a.m. every day, and it'll run remotely instead of on your machine. And the third is custom loop orchestration skills. It's a mouthful, but this is actually how I run all of my loops. I create a single loop orchestration skill that I run that kicks off the entire loop. It has all of the settings configured about what the goal is, how to complete the loop, how to verify it.

[00:03:32]In that same weather example I mentioned, I would have a single skill that would be {slash} check weather loop, and I would just type that into my terminal, and I would hit enter. Here's a prompt to help you create that custom loop orchestration skill. Block one is a trigger, and the next block is about actually doing the work. And I know we're going through these concepts pretty quickly, so I put together a free 5-day email series where I walk through a lot of the concepts we cover in this video. That's linked below and based on over 6,000 people that have gone through it, I'm highly confident that you're going to love it. But, if you don't, you can unsubscribe at any time. Block two is the execution skills. I have extensive videos on my channel about Claude skills, but in short, it is a save set of instructions that allows Claude to run the same thing every single time. Simply put, it's like a prompt that you have saved that you can easily rerun instead of having to type it. In the first block, we created a {slash} check weather loop and orchestration skill that runs the whole loop. Execution skills are different.

[00:04:23]These are the things that actually do the task. Each one is a single specialized job the orchestration calls.

[00:04:29]Of the four building blocks I'm going to cover, this is the most important. In my eyes, the rule is simple. You don't build a loop without battle-tested skills behind it. The reason for this is these skills know exactly how you want to get a task done. Back to the check weather loop. Say you didn't have a {slash} analyze workout skill, AI would just say, "It's raining, cancel your run." But, if I had a {slash} analyze workout skill that documented that I actually love running in the rain, the response would be entirely different.

[00:04:55]And this is why I use skill-driven loop development. Any loop I create has to have existing skills that I've already battle-tested. Here's a prompt to identify which skills make sense for your workspace. This will look at the current skills that you've already established and suggest loops based on those skills. This strategy is so important and it comes into play in the next block. Block number three is the goal and the verification. Every loop needs two things tied together. A goal, what you want done, and a verification, the rule that confirms you completed the goal. These go together, right? You can't have a goal unless you're able to verify the goal was complete. So, here's how you can do this for both technical and non-technical tasks. The technical example is a lot more straightforward.

[00:05:34]The goal could be launch a website to this domain and make sure it loads in under 2 seconds. To verify, AI could hit that specific domain, make sure it can see the content that it expects, calculate the load time, and then make sure that the {slash} engineer review skill approves all the changes. AI will then know exactly what's needed and then can verify the results and repeat in a loop until it's complete. So that's for technical tasks, but what about for non-technical things? Well, this is where it becomes a bit of an art, not a science. You need to bridge the abstract to verifiable. Look at the end of the technical example that I just mentioned.

[00:06:07]The slash engineer review skill has to approve the changes. How does a loop actually know if code is good or not?

[00:06:13]Well, AI is very good at writing code, so it could just say approved or not approved. The skill engineer review is set up to bridge the abstract if code is good to something verifiable, approved or not approved. And we used it in a technical example, but this is actually the key to creating loops for non-technical tasks. You have to figure out a way to verify the final result, even if it's not quantifiable. So for example, let's say you have a slash draft emails loop. The goal could be for any unread email draft response. The verification could be make sure all emails that don't have a response have a draft, and that draft has been verified by the slash email review skill, the slash writing voice skill, and the slash fact checker skill. You've now established key things you want to verify that are inherently abstract, but you've created a bridge to make them verifiable. And yes, quantifiable tasks are easier, no question. But if you choose the right non-technical task that you already have skills for, those can easily become quantifiable. And this is exactly why skill-driven loop development matters so much because once you have a skill, you can actually convert it to include a verification element. And this verification element could be at the end of the output from that skill, you could say approved or not approved, or a score from 1 to 10, etc. Here is a prompt that I've run in the past to help me convert a normal skill to a skill that can help with verification. And one pro tip here with the goals and the verification and all of this, if you can have different AI analyze the output, you'll be able to get a less biased opinion. One easy way you can do this in Claude is you could use the Codex plugin or you can have Claude spin up sub agents to analyze the work. Here's a prompt to enforce separate agent verification within your loop orchestration skills. Block four, the output and the memory. The output is obvious, right? A loop produces something, a document, updates code base, live site, Telegram messages, whatever you want the loop to produce.

[00:08:01]The non-obvious thing here that most people miss is the memory. Every loop starts from scratch unless you record what happened. And no memory means that there's no improvement and you'll end up wasting tokens because you keep hitting the same issues over and over again.

[00:08:13]Adadi Asmani has one line that sticks with me. The agent forgets, the repo doesn't. And from Anthropic docs, they say, "Provide a place to write notes, as simple as a markdown file." And so you really don't need to overthink this thing, but you need to document what the results of the loop are. Just use this prompt, which will update any of your loop orchestration skills, to write any lessons learned and run history in a specific document. Here you can see the prompt. It'll create an output and memory files. Now we know the four key building blocks, a trigger, execution skills, goals and verification, and output and memory. And before we apply this to build our first loop end-to-end, if this is your first video of mine, welcome the channel. But if this is your second or more, here is our anti-slop agreement. The visuals, the testing, the hours of research that went into this, this is entirely built for humans like you, not for AI robot scrapers. So all I ask is you subscribe as part of this agreement to help this content reach more people so I can keep doing these videos. Also, every video I give away a Claude Max subscription. So comment below with what you're building to enter. This video's winner is the goat, Bob Dobbs, who's working on a home management app. All right, that's enough of that. Let's go to part three, build your first loop today. The key here is you need to start small and follow skill-driven loop development. Ask yourself, what is the smallest thing you've already done and proved works that you can create a loop for. Once you've identified that, use the four condition test that I mentioned earlier, which again, quickly you can see on screen. And if it passes all that, it's time to create a loop. So if you already have an idea, here is a prompt to build out a loop with all of the concepts that I've mentioned in this video. Baked into that is everything that I've covered.

[00:09:43]Now, if you have no idea what to build, here is a prompt that leans on skill-driven loop development to identify candidates from your past session history. For either of these prompts and for any prompt that I covered in this or previous videos, screenshot it and then just send it into Claude and that's essentially the same as writing the prompt. And the best part of what this will create, which is a skill, is you don't have to think about using /loop or /goal to establish goals.

[00:10:07]You just get the loop orchestration skill that abstracts all of this complexity away from you. You just type that into Claude, hit enter, and then monitor the results. When you do this, one of my favorite features is that you'll notice both of these prompts have one important guardrail. I call it loop training mode. So, the first couple times you use a new loop, you want to make sure the loop pauses at every step until you approve the process. The reason for this is you want to verify that it's actually doing what you want it to be doing and it's not just burning through all of your tokens. When you have this loop training mode set up, the output could look something like this.

[00:10:39]Quick check before I burn the tokens.

[00:10:41]Then it waits for your approval and continues on the process. After you've done this and you know that the loop is doing what you want it to do, you can just turn testing mode off by running this prompt. And this is really important because you're going to get a deeper understanding of the process and ultimately these tokens aren't free, so this will save you money and it will save you time because you'll know the output is what you want. Now, before you go crazy with all these loops, I have one rule of thumb. If a goal is less quantifiable, then you need to break down loops into much smaller goals where the output is at key checkpoints in the process. Think of AI like an intern. If you just said, "Plan a corporate party," it could do anything, but you would probably want to have key checkpoints at what date to pick, where the venue is, and the theme of the party. And as somebody who throws an annual Christmas party, that's the party of the year in New York City, I I know how to throw a party, it needs a theme. But anyway, those decisions shape the entire party.

[00:11:33]It's the same with loops. What are the key moments where if the loop picks the wrong direction, the rest of the loop is entirely shot? Those are your human verification checkpoints. Ultimately, the more of these key verification checkpoints that you don't actually verify, the more the AI can go off course. So, be very mindful of that, specifically for non-measurable tasks.

[00:11:54]With all that, my favorite thing about loop engineering is the problem-solving muscle it'll force you to flex. So, go pick something small and build a loop orchestration skill for it. Now, if you like this video, you will love this video where I do a deep dive on the only Claude skills you need to 10x your output. The topics I cover there will help your loops go from good to great.

[00:12:13]I'll see you in the next one. Peace.