Big Idea

The argument in one line.

The most productive AI users have stopped writing prompts and started writing loops — self-running systems that do the prompting automatically until a goal is verified complete.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You already use Claude Code daily and find yourself re-prompting the same task types over and over.
You want to automate recurring workflows (email drafting, code review, content checks) without writing a full script.
You have some saved Claude skills and want to know how to chain them into autonomous agents.
You are technically curious but not a developer — the video explicitly addresses non-technical users in Part 3.

SKIP IF…

You have never used Claude Code or any AI coding agent — the trigger options (/loop, /schedule, skill files) assume familiarity with the Claude CLI.
You want deep technical implementation; this is a conceptual framework video, not a code walkthrough.

TL;DR

The full version, fast.

Boris Cherny (Claude Code creator) and Peter Steinberger (OpenClaw creator) both said the same thing: stop prompting, start writing loops. A loop is a prompt that runs until a goal is verified complete. You should build one when the task repeats, has a clear definition of done, can tolerate some token waste, and the AI has the tools to verify its own output. The four building blocks are: a trigger (how the loop starts), execution skills (battle-tested saved instructions), goal+verification (including a strategy for non-quantifiable tasks), and output+memory (a log that prevents the loop from repeating the same mistakes). Start with your smallest proven workflow, run it in training mode first, and add human checkpoints wherever a wrong direction would derail everything downstream.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:46

01 · Cold open — the signal

Boris Cherny and Peter Steinberger quotes frame the shift: stop prompting, start building loops. Credibility established before a single concept is explained.

00:46 – 02:34

02 · Part 1 — What a loop is

Definition: a prompt that runs until a goal is verified complete. Contrast with one-shot prompts. The 4-condition test introduced.

02:34 – 04:09

03 · 4-Condition Test deep dive

Four conditions: repeats, clear done-state, token-cost tolerance, AI has the right tools. Prompt to audit workspace shown on screen.

02:34 – 04:01

04 · Block 1 — The Trigger

Three trigger options: /loop (local), /schedule (cloud), custom loop orchestration skill. Tradeoffs explained.

04:01 – 05:15

05 · Block 2 — Execution Skills

Saved, battle-tested skill files as the non-negotiable foundation. Skill-driven loop development rule: no loop without proven skills.

05:15 – 07:53

06 · Block 3 — Goal and Verification

Every loop needs a goal and a paired verification rule. Technical and non-technical examples. Bridging the abstract to verifiable.

07:53 – 09:16

07 · Block 4 — Output and Memory

Memory prevents loops from repeating failures. Addy Osmani: the agent forgets, the repo doesn't. Log lessons learned to a markdown file.

09:16 – 12:15

08 · Part 3 — Build your first loop today

Start small, use existing skills, run in loop training mode first. The less quantifiable the goal, the more human checkpoints you need.

Atomic Insights

Lines worth screenshotting.

A loop is not a smarter prompt — it is a prompt that runs until a verifiable condition is met, which is a fundamentally different mental model.
The creators of the tools you use have already stopped prompting and started writing loops — that signal is worth paying attention to.
Never build a loop without battle-tested skills behind it; a loop is only as reliable as the sub-skills it calls.
Non-technical tasks can be looped too, but only if you can bridge the abstract to something verifiable — 'is the email good' becomes 'did /email-review, /writing-voice, and /fact-checker all approve it'.
The agent forgets, the repo doesn't — memory is the difference between a loop that improves and one that burns tokens hitting the same wall every run.
Loop training mode is not optional for new loops — pausing at every step to get human approval before burning tokens is the only way to validate the loop is doing what you think it is.
The less quantifiable the goal, the smaller the sub-goals must be and the more human checkpoints you need at decision forks.
Using a different AI to verify the output of your loop gives you a less biased judgment than having the same model grade its own work.
A custom loop orchestration skill abstracts away /loop and /schedule — you just type one slash command and the whole system kicks off.
The 4-condition test is a filter, not a formula: does the task repeat, is there a clear done-state, can you afford token waste, does the AI have the tools to verify completion?

Takeaway

How to turn a repeating task into a self-running system.

WHAT TO LEARN

The gap between a power user and someone who has left the prompting era is a loop with a verification rule — and building one is simpler than it sounds.

A loop is a prompt with a stop condition, not a fancier prompt — the mental model shift is from 'send a message' to 'design a system that sends its own messages until done'.
Before you build a loop, the task must pass four filters: it repeats, you can define done, you can afford some token waste, and the AI has tools to verify its own output.
The order matters: build and battle-test your execution skills first, then wire them together into a loop — a loop is only as reliable as the skills it calls.
Non-quantifiable tasks can still be looped if you route the quality judgment through a trusted review skill that returns a binary verdict rather than a subjective opinion.
A loop without a memory file hits the same failures every run — logging lessons learned after each execution is what turns a loop into something that improves over time.
Loop training mode — pausing for human approval at each step during the first few runs — is the only reliable way to validate a new loop before it runs autonomously and burns tokens on the wrong path.
The less measurable the goal, the more human checkpoints you need at the forks that would derail everything downstream if the AI picks the wrong direction.
Using a separate AI model to verify the output of your loop gives you a less biased judgment than having the same model score its own work.

Glossary

Terms worth knowing.

Loop (agentic loop): A Claude prompt that runs repeatedly — checking its own output against a verification rule — until the goal is confirmed complete rather than stopping after one response.
Loop orchestration skill: A saved Claude skill file that acts as the master controller: it holds the trigger, goal, verification logic, and memory config so a single slash command kicks off the entire loop.
Execution skill: A saved, battle-tested Claude skill for a single specialized sub-task (e.g., /email-review, /engineer-review) that a loop orchestration skill calls as a step in the workflow.
Loop training mode: A guardrail baked into a loop orchestration skill that pauses execution at each step and asks for human approval before continuing — used for the first few runs to validate behavior before running autonomously.
Bridge the abstract: The practice of converting a qualitative outcome (is this code good?) into a binary verifiable output (did /engineer-review return approved?) so a loop can act on it programmatically.
Definition of done: An explicit, checkable condition that tells the loop when to stop — the equivalent of a sprint acceptance criterion but stated in natural language for the AI.
Skill-driven loop development: The practice of only building loops on top of existing, proven skill files rather than writing new instructions inline — ensuring each step already works reliably before being automated.

Resources

Things they pointed at.

00:05linkBoris Cherny quote on loops

00:11linkPeter Steinberger tweet — June 2026

08:05linkAddy Osmani — Google Cloud AI

07:33toolCodex plugin for Claude Code

03:58linkFree 5-day AI playbook ↗

03:58productBuildPartner.ai ↗

Quotables

Lines you could clip.

01:14

“Instead of prompting Claude a hundred times to complete a task, you should now be thinking about how to create loops to accomplish clear goals.”

Clean restatement of the core shift — works without any context→ TikTok hook↗ Tweet quote

04:30

“You don't build a loop without battle tested skills behind it.”

Quotable rule of thumb, punchy, standalone→ IG reel cold open↗ Tweet quote

08:05

“The agent forgets, the repo doesn't.”

Third-party line but perfectly encapsulates the memory argument→ Newsletter pull-quote↗ Tweet quote

10:37

“Quick check before I burn the tokens.”

Concrete example of loop training mode output in practice→ Demo clip for loop training mode explainer↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

analogy

00:00Boris Churney, the creator of Clawd Code, just said something that should change how you use AI forever. He said, I don't prompt Clawd anymore. My job is to write loops.

00:07Then I found a tweet from Peter Steinberger, the creator of Open Claw, saying the exact same thing. You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents.

00:16There'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.

00:28Most 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.

00:36Part 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:49Unlike 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. Listen to how Boris thinks about his day to day now. Now it's actually leveled up, I think, again to the next wave of abstraction where I don't prompt Claude anymore.

01:06I have loops that are running. They're the ones that are prompting Claude and kinda figuring out what to do. My job is to write loops.

01:11So it's clear. Instead of prompting Claude a 100 times to complete a task, you should now be thinking about how to create loops to accomplish clear goals. This sounds great, but when should you actually use it?

01:20Well, 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.

01:28Second is, is there a clear definition of done? When I was the COO of a $25,000,000 tech startup, whatever task we were doing, we wanna have a clear definition of how we would quantify if the task was done.

01:39And a lot like humans doing tasks, the most successful loops have a clear definition of done and a way to verify the results. Now, is an art and not necessarily science, we'll cover that in a bit. Three is can you afford to be wasteful?

01:51So loops will automatically prompt itself until a task is complete. 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 wanna be a bit more strategic using this.

02:04And 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 the website is live and accessible to anyone? These tools will be used in the verification and the implementation process.

02:17If 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.

02:32But how do you build a loop that actually works? Part two is the four building blocks for successful loops. Loops.

02:37The first block is the trigger. This is what starts your loop. Every loop needs a trigger.

02:42This 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.

02:48If 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.

03:02So if you close your laptop, it'll just stop. The second is slash schedule. This lets you run something automatically in the cloud at any time or day in whatever cadence you want.

03:11So you can run the prompt that I had just mentioned for the loops, but instead have it run at 8AM 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.

03:23I create a single loop orchestration skill that I run that kicks off the entire loop. It has all the settings configured about what the goal is, how to complete the loop, how to verify it. 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.

03:40Here'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 this concept pretty quickly, so I put together a free five day email series where I walk through a lot of the concepts we cover in this video.

03:54That's linked below and based on over 6,000 people that have gone through it, I'm highly confident that you're gonna love it. But if you don't, you can unsubscribe at any time. Block two is the execution skills.

04:03I 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.

04:16In the first block, we created a slash check whether loop, an orchestration skill that runs the whole loop. Execution skills are different. These are the things that actually do the task.

04:25Each one is a single specialized job the orchestration calls. Of the four building blocks I'm gonna cover, this is the most important. In my eyes, the rule is simple.

04:33You 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.

04:43Say you didn't have a slash analyze workout skill, and I 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. And this is why I use skill driven loop development.

04:58Any 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.

05:11This 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.

05:19A goal, what you want done, and a verification, the rule that confirms you completed the goal. These go together. Right?

05:25You 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 nontechnical tasks. The technical example is a lot more straightforward.

05:34The goal could be launch a website to this domain and make sure it loads in under two 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.

05:55So 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.

06:05Look at the end of the technical example that I just mentioned. The slash engineer review skill has to approve the changes. How does a loop actually know if code is good or not?

06:13Well, AI is very good at writing code, so it could just say approved or not approved. This skill, engineer review, is set up to bridge the abstract if code is good to something verifiable, approved or not approved.

06:26And 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.

06:39The goal could be for any unread email draft response. The verification could be make sure all emails that don't have 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.

06:54You'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.

07:03No question. But if you choose the right non technical tasks that you already have skills for, those can easily become quantifiable. And this is exactly why skill driven loop development matters so much.

07:13Because once you have a skill, you can actually convert it to include a verification element. And this verification could be at the end of the output from that skill, you could say approved or not approved, or a score from one to 10, etcetera.

07:26Here 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 verification and all of this, if you can have a different AI analyze the output, you'll be able to get a less biased opinion.

07:40One easy way you can do this in Claude is you could use the Codex plug in 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 orchestration skills. Block four, the output and the memory.

07:54The output is obvious. Right? A loop produces something.

07:56A document updates code base, a live site, telegram messages, whatever you want the loop to produce. The non obvious thing here that most people miss is the memory. Every loop starts from scratch unless you record what happened.

08:07And 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. Addy Azmani has one line that sticks with me. The agent forgets, the repo doesn't.

08:18And 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, will update any of your loop orchestration skills to write any lessons learned and run history in a specific document.

08:35Here 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.

08:44And before we apply this to build our first loop end to end, if this is your first video of mine, welcome to the channel. But if this is your second or more, here is our anti SLOP agreement. The visuals, testing, the hours of research that went into this, this is entirely built for humans like you, not for AI robot scrapers.

08:59So 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.

09:15Alright. That's enough of that. Let's go to part three, build your first loop today.

09:19The 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.

09:33And 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.

09:43Now, 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, that's essentially the same as writing the prompt.

10:00And the best part of what this will create, which is a skill, is you don't have to think about using slash loop or slash goal to establish goals. You just get the loop orchestration skill that abstracts abstracts all this complexity away from you. You just type that into Claude, hit enter, and then monitor the results.

10:15When 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. The first couple times you use a new loop, you wanna make sure the loop pauses at every step until you approve the process.

10:28The reason for this is you wanna 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. Quick check before I burn the tokens.

10:41Then 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 gonna get a deeper understanding of the process, and ultimately, these tokens aren't free.

10:56So 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.

11:13Think of AI like an intern. If you just said plan a corporate party, it could do anything, but you would probably wanna 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.

11:30It needs a theme. But anyway, those decisions shape the entire party. It's the same with loops.

11:34What 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.

11:51So be very mindful of that, specifically for non measurable tasks. With all that, my favorite thing about loop engineering is the problem solving muscle. It'll force you to flex.

12:00So 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 10 x your output. The topics I cover there will help your loops go from good to great.

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

The Hook

The bait, then the rug-pull.

Two people who literally built the tools we are using have independently said the same thing: stop prompting, start writing loops. That kind of convergence from tool authors is worth slowing down for.

Frameworks

Named ideas worth stealing.

01:33list

4-Condition Loop Test

Does the task repeat?
Is there a clear definition of done?
Can you afford to be wasteful with tokens?
Does the loop have all the tools it needs to complete and verify the task?

A filter for deciding whether a task should become a loop or stay a one-shot prompt. All four must pass.

Steal forAny workflow audit — run this before automating anything

02:34list

Four Building Blocks of a Successful Loop

Trigger — what starts the loop
Execution Skills — battle-tested saved skill files for each sub-task
Goal + Verification — what done looks like and the rule that confirms it
Output + Memory — logs of results and lessons so each run improves on the last

The complete anatomy of a working agentic loop. Missing any one makes the loop unreliable.

Steal forDesigning any Claude Code automation workflow

04:01concept

Skill-Driven Loop Development

Never build a loop before you have battle-tested execution skills. The skill defines exactly how a task gets done and provides the verification vocabulary the loop needs.

Steal forSequencing automation: skills first, loops second

06:02concept

Bridge the Abstract

For non-quantifiable goals, convert subjective quality into a binary verifiable output by routing through a trusted review skill that returns approved or not approved.

Steal forAny content or quality loop where good enough is hard to define programmatically

10:45concept