Stop Prompting AI Agents. Build Loops Instead. transcript

If you are still typing prompts into Claude code, waiting for it to build, testing the build yourself, finding what broke, and then typing the next prompt, you're not really using an agent. You are the agent. Claude is just a worker waiting for instructions. The real unlock is when you stop prompting one step at a time, and instead build a loop that gives the agent a goal, lets it work, forces it to test itself, and only comes back to you when it's done, blocked, or needs approval.

That is what people are calling loop engineering. So, in this video, I'm going to build a real loop with Claude code, then I will show you how the same idea applies to code [music] X, cursor, Hermes, and basically almost every AI agent, because the goal is not better prompting. The goal is fewer prompts. So, let's get started. Let me show you the trap this solves. You open Claude code and say build this feature. It built something, you run it, it breaks, you copy the error back into Claude, it fixes one thing, you run it again, a different thing breaks, then you realize the agent changed files you never wanted it to touch.

So, now you're reading the code manually trying to figure out what happened. The agent is writing code, but you are still the project manager, the tester, and the reviewer. A prompt gives the agent one instruction. A loop gives the agent an entire process. And before you build one, you need to know when a loop is actually worth it. Before you turn everything into a loop, you need a filter, because not every task deserves a loop.

Some tasks should just be one prompt. So, I use four questions. First, does the task repeat itself? If this is a one-time thing, do not overcomplicate it. Just prompt the agent and move on. Second, is there a clear definition of done? For code, that might be tests passing. For content, that might be every recommendation has a source, a transcript, and no pipeline conflict. If the loop cannot tell whether it succeeded, it will never be able to successfully get the job done.

Third, can you afford the cost? Loops can burn tokens fast. If the loop keeps retrying without learning, your wallet will feel it. And fourth, does the agent have the tools it needs? If you want it to check a website, it needs browser and network access. If you want it to fix code, it needs file access and test. If the answer to that question and to all four are yes, then you probably have a good loop candidate. Repeat, definition of done, acceptable cost, necessary tools.

Those are right there, the filters. And once a task passes that filter, the next question is not what prompt should I write? The next question is, what pieces does this loop need so it does not turn into chaos? The simple version of loop engineering has four parts. A trigger, an execution skill, a goal plus a verifier, and an output plus memory. The trigger is what starts the loop. That could be manual, like you typing a command into Claude code.

It could be scheduled, like every morning at 8:00 a.m. It could be event-based, like a new support ticket opens up or a failed test shows up or a new Notion status, something like that. The trigger matters because a loop should not rely on you remembering to start it every single time. The second part is the execution skill. This is the actual work the agent knows how to do. Not a vague wish like make my app better, real procedure.

Maybe you have a web design skill or a fact-checking skill. Then you can use those skills inside of your loop. So, every time your loop runs, it knows exactly what it has to do step by step. And then the third part is the goal plus the verifier. These two have to live together. A goal without a verifier is dangerous because the agent has no way to know if the goal is complete. A verifier without a goal is also useless because the agent can check things forever without knowing what the finish line looks like.

For coding, the verifier can be tests, a build, or a code review. For content, the verifier can be a rubric, like is it source-backed, not already posted, does the title match the promise, so on and so forth. And the fourth part is output plus memory. A loop should leave something behind, a changed code base, a task update, a log of what it tried, what worked, and what it learned. Because without that log, every run starts cold.

With the log, the loop gets easier to debug and safer to improve. So, the full pattern, as you can see here, is simple. Trigger starts it, execution skill does it does the work, goal and verifier decide whether it worked and whether it's done, and output plus memory make the result useful after the run ends. Now, the mistake would be trying to invent all of this from scratch. Because the best loops usually come from workflows that already work manually.

This is the part I think people will mess up the most. They're going to hear loop engineering and immediately ask an agent to automate some giant messy workflow they barely understand themselves. That's how I started, at least. The best loops come from workflows you already know how to do manually or with Claude code. If I already have a good process for editing a YouTube video, for example, then I can turn that into a loop.

If I have a great skill around it, guess what? I can turn that and use that skill inside of my loop. And the good news is I can create skills along the way that I end up using inside of my loop. For example, I have a skill called YouTube edit that knows exactly how to download my raw filming material, fix the audio, cut the silences, filter out the double takes that I make throughout my videos, add animations on screen, so on and so forth.

That workflow already works manually. When I go into Cloud Code and tell it, "Hey, use my YouTube edit skill to edit this video. Here's its Google Drive link and here's the video's title." And promise, the loop, it already knows how to do it. The loop just makes it repeatable. Same with coding, if you have a coding workflow. So, the question is not what crazy autonomous agent can I build? The better question is, what boring work have I already proven that I can now make repeatable?

This is why I like building loops from skills and repeated tasks. So, let me make this video practical by us building a loop together. I want to use a loop I would actually want in my business. Every time I finish filming a YouTube video, I move that inside my Notion from to film onto filmed. That is the trigger I want to start this loop off. And once that happens, I do not want to manually download all the footage, fix the audio, cut the silences, check the edit, export a preview, so on and so forth, and then render in 4K.

I already have a skill for that. And that is basically the skill I just mentioned, my YouTube edit skill. It knows the way I want the video edited, how to handle the raw filming material, how to fix the audio, and how I want my finished video to look like. So, the loop I want to build is exactly this. Here is the kind of prompt I would give Claude Code. I want you to help me build a Notion triggered YouTube editing loop.

The goal, every time a video in my Notion content board moves from to film to filmed, start the editing process using my existing YouTube edit skill. The trigger, a Notion page changes from to film to filmed. Context, the Notion page contains the video title, script, raw footage links, so on and so forth. Execution skill, use the YouTube edit skill as the editing procedure. Do not invent a new editing style. Read the skill first and follow its criteria.

And then I go into defining the loop. The loop is number one, detect the Notion status change. Number two, read the video page and collect the raw footage. Number three, run this YouTube edit skill. Number four, create a low resolution preview first. This is very important. Uh number I jumped into number six. Run the verifier on the preview. Number seven, if the verifier fails, fix the edit and create a new preview. So, don't tell me this passed until you fix everything that is within my skill.

My skill has a list of checklists, basically, and it needs to check them off one by one. If one of those checklists fail, then it repeats and repeats and repeats until it is resolved. Number eight, if the verifier passes, show me the preview, the editing summary, and the verifier report. Number nine, wait for my approval. This is where I step in as the human and watch the video. I mean, Claude Code can see audio graphs.

It can take screenshots in different places, but it can't have my personal taste. So, this is where I need to come in and be the human verifier myself as well. Only after my approval, render the final version in 4K. Then, I have to do three things to tell it when to stop, stop when the preview passes verification, and if I approve, then render in final 4K. Stop and ask me if this happens. Do not do this, so the do not.

And then, finally, let's start building this loop in training mode step by step so we can ensure every step works as intended before we finalize this loop. This is very important, and we're going to get into why in just a second. But, that is the prompt that I pasted into Cloth Code. I will be giving you the same exact prompt template in a few minutes as well, so you can end up using it yourself. And what it did, it asked me a couple of questions.

I told it, "Hey, you can find my Notion token inside of my desktop, inside this folder." And it went on, it created the first part of my loop, and then it asked me, "Let's try move one of your content pieces from to film over to filmed." And I did so, and there you go. Here you go. It said, "Move this video, learn 95% of Hermes Agent in 29 minutes." Told it I just moved it in Notion, and boom, just like that, it downloaded all 11 filming material that I had filmed.

It asked me a few more questions, remember, cuz we're training, right? I'm asking it to stop every step of the way and ask for verification until we have trust in the system that it works. After it asked me those questions, it literally went on like a 30-minute run. Finally, after 37 minutes, it came back and gave me a preview over here. Here is the preview it gave me, and remember, this is in low resolution because I want to verify how this video looks first, so let's give it a watch. >> Hermes Agent is one of the most powerful AI tools in the world right now, but it has one of the worst beginner problems.

You install it, open it, and then immediately >> There you go, so you see it's cut through the silences and it's incorporated >> the different things I asked for. >> feeling like a real assistant that can operate your entire life. Let's get started. The easiest way to understand Hermes >> But there you go, the one thing that it missed was adding my on-screen animations when I watched this video. So I went over and I told it, "By the way, you forgot to add on-screen animations.

Is this not part of my YouTube edit skill already, or did you just not do it?" By the way, the edit is fire, great job, and it went on, it evaluated, and it gave me another preview. Here it is. >> this video, Hermes should stop feeling like a confusing AI toy and start feeling like a real assistant that can operate your entire life. Let's get started. The easiest way to understand Hermes >> There we go, it added on-screen add-ons and animations, but there are a few comments left as I'm watching it.

For example, there are not 15 sections to this video, there are about eight. So I'm going to go ahead and fix that, ask it to fix that. But that is exactly why we wanted to start in training mode to make sure that every step of the way is defined properly and works properly before we can go ahead and turn that into a loop because imagine I just make this as the finished product, the loop, then every single time that loop will run with a new video, I will have to do hundreds of things to end up cleaning it up, which takes us back to step one, which is just prompting back and forth and back and forth.

There are two things that we absolutely need to nail in this step when building out our loops. And the first one are our verifiers. Something very important for you to do is to automate the things that you can measure. Good verifiers are things that the machine, Claude Code, or Hermes, or Codex, whatever LLM you're using, can actually verify those things and they're not vague things. For example, are there black frames in the video?

Is there AV drift? Are there words that are clipped in the middle? Like, when I'm saying something, are you clipping me like right in the middle of me speaking? Does it match the plan? Those are things it can verify as a computer. But, the things it cannot verify, that should be owned by me, the human, is does the video feel right? Does do I spend too much time yapping about something when I shouldn't be? Should something be entirely cut out?

Should humor be left in or kept out? Those are things that I, as a human, should still direct. So, the verifier has to be things that your machine can automate, can measure, so that it can know and have a checklist of, "Okay, I'm done with this. I'm done with that. Boom, boom, boom, boom." So on and so forth. The second thing is training mode. This is why at the end of our prompt, we put a training mode. Because odds are in your first run ever of that loop, a lot of things are going to break.

It's not going to be a hundred, a thousand percent perfect, which is why in run one, you want it to stop and ask you, "How am I doing here? How am I doing here? What would you change here? What would you change there?" And you would go ahead and fix that so that in run, for example, five, there are maybe two checkpoints where you come in and check in and approve. And maybe by run 20, that would be the goal, is that it only has one approval gate instead of 20 different approval gates where it needs to check in with you.

So, for example, with this current loop that we made together in this video, I always want it to give me a lower definition render so I can watch it before it makes a 4K render because a 4K render uses a lot of time, uses a lot of my CPU, it uses a lot of my processing power, and it takes so much time. So why waste all that time when it can just give me a low resolution edit? I can verify it looks good, looks great. If I want to change anything, I can do it quickly, re-render it out within minutes instead of it taking hours, and then I can give that approval, and we have that final 4K edit.

The autonomy increases only when the loop proves that it deserves it. I am using Claude code here because this loop has code around it. Claude code is good for building systems like that, but Hermes is where this kind of loop becomes part of your actual work because Hermes can sit in the middle of the operating system, and it can stay quiet when nothing needs me. That is why I think Claude code is great for coding loops, but Hermes is better for operator loops.

Claude code builds the machine, Hermes can help run the machine. Before you turn every workflow into a loop, there are some loops you should not build. Do not build loops for vague goals. Things like make my videos better is not a loop, that is a wish. Edit this video using my YouTube edit skill, create a preview, verify these specific criteria, wait for my approval, then render in 4K. That is a specific, measurable, good loop.

Do not build loops where the agent cannot verify the output. If there is no test, checklist, or human checkpoint, the loop has no idea if it is improving or just moving, and not just that, it has no idea when to stop so it will keep going on and on forever and consume everything that's in your wallet. So do not build loops around expensive work without on preview, for example, rendering 4K before approval is a waste if the edit is wrong.

And do not build loops around external actions without permissions. Things like uploading, publishing, emailing, deleting files, or sending something to a client should have a clear approval gate. The best loop is not the one that does the most without you. Best loop is the one that removes the the boring work while keeping the important judgment with you. If you want to build your first loop, use this structure right here.

I want you to work in a loop with the goal where you input your exact outcome, the trigger where you name what starts this loop, the context where you include your files, your Notion pages, your constraints, examples. So, what is the context of this loop? The execution skill where you list out what skills are you going to use inside of [clears throat] that loop? Then the verifier, how the agent checks whether the output is actually good or not.

Then you input the loop, how do you want it to go about? What are the exact steps it will do step-by-step along with training mode, a stop when condition, a stop and ask me if condition, and a do not criteria, the things that it should not absolutely should not do, as well as a memory or log. The great thing here is you can screenshot this very frame and send it to your LLM, send it to your Claude Codec, Hermes, and it will read it for you.

So, literally screenshot right now the prompt as is and tell it I want to use this, take it, and help me apply it to my own loop. That is the shift, my friend. You're not trying to write the perfect prompt anymore. You're trying to design the loop that prompts the agent for you. Look, the point of AI agents is not that you can send them longer prompts. The point is that you can build systems where the agent knows what to do after that first prompt.

Prompting makes the agent useful for one step. Loops make the agent useful for a process. And if you build the loop properly with the right trigger, the right execution skill, the right goal and verifier, and the right memory and context, then your agent stops feeling like a chatbot and starts feeling like an operator. So, the next time you catch yourself prompting cloth code for the fifth time in a row, do not ask yourself, "How can I write a better sixth prompt?" Ask yourself, "What loop should have existed before I started?" Comment loop if you enjoyed this video and want more like it.

And make sure to subscribe if this is your first time watching any of my videos, because I have a ton more content coming your way. Oh, and would you look at this? The algorithm gods just told me you're very likely to enjoy this video as well. So, click it and I'll see you there.