Video of the Day09:43Nate Herk | AI Automation · Tutorial
Claude Code Scheduled Tasks: The 24/7 AI Employee
A 9-minute demo showing how native cron sessions turn any Claude Code skill into a self-healing, self-improving background agent.
March 7thThe argument in one line.
The verification step — defining what done means and giving the agent a concrete way to check it — determines loop quality more than any architectural choice, and a single well-prompted solo loop beats a fleet of agents with a vague goal.
Read if. Skip if.
READ IF YOU ARE…
- You use Claude Code for knowledge work and have seen loop-engineering tweets making you feel behind.
- You want a clear mental model of agent loops before building anything.
- You are a non-coder or solo builder who needs the concept without the hardcore-engineer framing.
- You have started wondering whether 24/7 agent fleets actually apply to your work.
SKIP IF…
- You are already running production multi-agent systems and need implementation depth rather than concept explanation.
- You need copy-paste code patterns — the demos are screencast walkthroughs, not code templates.
The full version, fast.
Agent loops boil down to one cycle: reason, act, observe, repeat until a stop condition is met. The video argues that the quality of your done-check matters more than whether you use one agent or ten — a subjective until satisfied goal produces worse results than a hard metric like stop when score is above 9. Three live demos show loops closing in on quality across iterations without ever reaching perfection. The main message for non-engineers: most tasks only need a solo loop in one terminal session, and mimicking a hardcore coder running 72-hour agent fleets is probably the wrong move for knowledge workers.
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 →Where the time goes.
00:00 – 00:31
01 · Cold open — the anti-hype frame
Live loop demo on screen, then the core question: productive or just a cool demo?
00:31 – 02:23
02 · What loop engineering actually means
Defines loop engineering as replacing yourself as the prompter. Two pillars: goal (objective) + verification (stop condition). Shows tweets from Peter Steinberger and Boris Churney, then a custom HTML explainer.
02:23 – 05:29
03 · How an agent loop works
Reason → Act → Observe cycle. Quality vs. Attempts curve showing agent loop jumps higher on attempt 1. Internship analogy. Covers solo loop, maker-checker, and manager-with-helpers patterns.
05:29 – 06:13
04 · Three loop types you will actually use
Most tasks don't need loops — but the verification habit is worth building. Three patterns: solo, maker-checker, manager.
06:13 – 08:12
05 · Demo 1 — Thumbnail scoring
Claude Code /goal: generate 10 thumbnails, score vs. MrBeast rubric, iterate on top 3. Took 27 minutes. Problem: subjective done criteria. Lesson: need objective metric or dedicated scorer sub-agent.
08:12 – 09:08
06 · Demo 2 — Three.js plane
37-minute loop from Matthew Berman's loop library. Agent built and visually verified a spinning 3D plane in the browser. Result imperfect but far better than a one-shot prompt.
09:08 – 10:31
07 · Demo 3 — Abbey Road HTML recreation
Agent recreated Abbey Road album cover in HTML/CSS across 7 versions, stopping when score >= 9. Visual verification via browser screenshots each round. Honest result: still nothing like the photo, but showed the process working.
10:31 – 12:40
08 · What makes a loop actually work
8 ingredients: checkable goal, hard stop, good tools, memory, separate checker, planning first, logging, cost awareness. Examples from his video-editing loop with Hyperframes.
12:40 – 14:06
09 · Does this apply to you?
Peter Steinberger is a hardcore coder at OpenAI — his workflow does not transfer 1:1 to knowledge workers. Use cadence or event-based loops; overnight runs of 4-8 hours can be valuable; 3-day runs usually are not.
14:06 – 14:33
10 · Resources + CTA
Points to free Skool community for the slide deck and full audit doc. Subscribe ask.
Lines worth screenshotting.
- The quality of an agent loop is determined almost entirely by how objectively you can define done — a vague stop condition produces worse output than a hard metric.
- Most tasks do not need a complex agent architecture; a single agent reasoning, acting, and observing in one terminal session captures most of the benefit.
- Loops do not give you perfect output — they give you much closer output on the first human review, which is the actual value.
- Outsourcing the feedback-and-iteration cycle to an agent does not remove iteration; it shifts who does it.
- A 24/7 fleet of agents is only useful if your work actually benefits from constant autonomous throughput — for knowledge workers, cadence-based or event-triggered loops are usually enough.
- The best done-check is a machine-readable metric; the second-best is a rubric scored by a dedicated sub-agent; subjective satisfaction criteria are last resort.
- Running loops that go twelve hours and produce nothing useful is a cost and time problem, not a sign the loop concept is broken — shorten the done criteria.
- Mimicking a hardcore software engineer workflow when you do knowledge work is like using a forklift to move a box across the room.
- A maker-checker pattern produces more reliable iteration than a single agent self-grading.
- Visual verification is a distinct check type from functional verification — a browser screenshot loop and a test-suite loop need different tools and criteria.
- The human role in a well-designed loop is defining the goal and the done-check, not supervising individual steps.
- Spending 37 minutes on a loop that produces an imperfect but vastly better result is still faster than manual iteration to the same quality.
The done check is what makes a loop worth running.
WHAT TO LEARN
Agent loops are not about architecture complexity — they are about having a concrete, checkable definition of done that the agent can test against without asking you.
- The reason/act/observe cycle is the same under every agent architecture — solo, maker-checker, or multi-agent fleet. The architecture is secondary to the quality of the stop condition.
- The most common mistake is a vague done criteria like until satisfied — replace it with a measurable threshold (score >= 9, tests pass, screenshot matches reference) whenever possible.
- Most tasks benefit from the verification habit without needing a complex loop — a single agent that self-checks before stopping beats a fleet of agents with no clear finish line.
- Loops do not produce perfect output; they produce much better first-review output. Set expectations accordingly and budget your iteration cap before you start.
- Verification type should match what you are building: functional checks for code, visual checks for design or UI, judgment rubrics for content — the agent needs the right tools to run the right check.
- Running a loop for 12 hours that produces nothing actionable is a goal-design failure, not a loop failure. Shorten the scope or sharpen the done criteria before extending runtime.
- Someone else's agent workflow is optimized for their context. A coder shipping a product daily benefits from 24/7 loops; a knowledge worker or solo builder usually needs cadence-based or event-triggered loops instead.
Terms worth knowing.
- Agent loop
- An AI that cycles through reasoning about what to do, acting on that reasoning, and observing the result — repeating until a defined stop condition is met.
- Loop engineering
- Designing the system that prompts and directs an agent, rather than prompting the agent yourself — replacing yourself as the human in the loop.
- Done criteria / stop condition
- The objective or semi-objective check an agent uses to decide whether to stop iterating or take another pass. The more measurable, the better the loop.
- Maker-checker pattern
- A two-agent setup where one agent produces output and a second agent evaluates it and provides feedback, improving objectivity of the grading step.
- /goal (Claude Code)
- A slash command in Claude Code that launches an autonomous loop: the model runs until it judges the goal met or hits a hard cap, without requiring human prompts between steps.
- Solo loop
- A single agent reasoning, acting, and observing in a loop — the simplest and most commonly useful form of agent loop for non-engineering tasks.
- Verification
- The observe step of a loop — how the agent checks whether its output meets the done criteria. Can be functional, visual, or judgment-based.
Things they pointed at.
06:13linkMatthew Berman Loop Library
10:31toolHyperframes
Lines you could clip.
00:08
“But is this actually productive, or is that just a cool demo?”
05:19
“The majority of tasks don't need loops.”
10:31
“A loop is only gonna be as good as its done check, as the done criteria.”
12:55
“Just because you're seeing someone like Peter Steinberger saying something like this doesn't actually mean that this applies directly to you and your use case because he's a hardcore coder.”
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.
analogystory
00:00Right here, I've got four different agents that are looping, calling other sub agents, and writing all these prompts for me and designing systems for me. But is this actually productive, or is that just a cool demo? Here's your monthly reminder that you shouldn't be prompting coding agents anymore.
00:12You should be designing loops that prompt your agents. Boris Churney and Peter Steinberger publicly said they no longer prompt their coding agents. They write loops.
00:20A loop is three things, a trigger, an action, and a stop condition. If you're still writing loops that prompt coding agents you're falling behind, you need to build a meta agent that infers what loops you would have wanted based on your vibe and then write those loops. We're seeing a ton of talk about agent loops, loop engineering, whatever you wanna call it, so I wanted to make a video to clear up what that actually means.
00:37Because I think that everyone kind of has their own spin and a different definition of what this is, and it applies to everyone very, very differently. I think that this definition sums it up pretty well. Loop engineering is replacing yourself as the person who prompts the agent.
00:50You design the system that does that instead. A loop here can be thought of as a recursive goal where you define a purpose and the AI iterates until complete. And there's really two most important pillars of that in my mind, which are the goal.
01:03What is the actual objective? Something typically that's objective, not subjective.
01:07And then verification. How does the agent know what that stop condition is? How does it check and iterate?
01:12So anyways, if you take all that advice and then you start doing stuff like this and designing swarms and fleets of agents that constantly run twenty four seven, then you need to think about what are you actually doing here, and is this actually moving the needle? So first of all, I thought to myself, how do I actually use agent loops?
01:26Because when you read some of those tweets that I just showed earlier in this video, you kind of think to yourself, okay. If I'm not having five agents that are continuously around the clock orchestrating five of their own agents, then I'm falling behind or I'm not using my cloud subscription in the best way.
01:40And I think that that's very false. Because if you don't understand what you're doing, then you're probably just gonna scale problems, and you're gonna have a ton of bugs and a ton of things that you're gonna have to fix later. And, also, not all of us are in a scenario where having agents work twenty four seven around the clock actually benefits us.
01:55For example, I don't. I have agents that do things on a certain cadence, and I have agents that do things based on certain event actions, but just having them do twenty four seven work for me isn't helpful.
02:05I think if I was working with a team on a code base and we were building a product and we were constantly iterating and pulling in different things, then it would maybe make more sense. But for me, that doesn't apply. So I just wanted to come in here, explain this as simple as I can, and hopefully shed some light on where you guys can start applying loops into your workflows and why and how.
02:23So I actually built an agent loop for this HTML that we're gonna look at today, and it basically went through a ton of different sources. It checked 45 sources whether that was articles, YouTube video transcripts, x post. It looked through a ton of stuff, and then it kept looping on this until it had a good idea of what to build.
02:38And then once it built this HTML, this wasn't v one. This was probably v seven.
02:42It had to keep checking, screenshotting, reviewing, iterating, and then it finally said, okay. We're done. This is what we got.
02:48So let me walk through this with you guys. An agent loop is just an AI that reasons on what to do, acts on what to do, starts implementing, and then it observes the result.
02:56And it will do that over and over and over until some sort of goal is met, until it knows we've hit the stop criteria. This is good. I'm going to stop now.
03:04And a really simple visual that I like to think about is AI is never perfect. Right? It's never gonna one shot something and you just accept that final output.
03:11And so if we have attempts on the x axis and we have quality on the y axis, let's think about this. On attempt one, if you are just giving your agent some sort of simple task, maybe you get to like let's just say attempt one, you get to 50%. And then you look at that and say, okay.
03:24Here are some changes to make. And then by attempt two, maybe you bump up another five or 10%. And every time that you give more feedback and iterate, you just kinda keep moving up on quality until you hit somewhere where you're okay with that 95%.
03:36And so the whole idea is why don't we outsource this part, this feedback and iteration loop to an agent rather than having the human do that? Because this is gonna happen either way. So if we have an agent do that instead of a human, then what might happen is on attempt one, we will go straight up to here.
03:52And then we can give a little bit more feedback, and then by attempts, you know, three or four, we're already so much higher than where we would have been without sort of that agent verification loop right there. And that's why a lot of people are explaining this in a different way where some people have the think act c.
04:05You know, we basically like reason, act, observe, reason, act, observe. Some people have the model just going back and forth with tools, back and forth, back and forth. Some people have just, you know, a goal that runs completely unattended, and some people are using these, like, fleets of agents with managers prompting other agents prompting other agents, and it's just like, you know, those Russian nesting dolls.
04:22So that's why I wanted to put this into kind of the main pillars, which I think are reason, act, observe. Think of this like a smart intern that you don't micromanage. You hand them a goal, they figure out what to do next, they check their own work, and they go again, and then they only come back to you and say, hey.
04:36I'm done. After they probably checked it a few times and made some changes. So you would say, okay.
04:40Claude code. Here's what I want you to do. We as humans are really, really good at defining what we want.
04:45We're really good at defining an end goal. And then on top of that, we have to say, okay. How do you know when that is done?
04:52So when you're making a cake, you stick the fork in it. And when it comes out and it doesn't have batter all over it, that means it's done. How do you tell your agent something as objective as possible?
05:01What is the stop criteria? What is the definition of done? And so what it will do is it will reason, it will plan out, and then it will start to implement.
05:08After it implemented, it will observe. So maybe that's visual verification, maybe that's running an actual code test. Whatever it means to verify, it has to verify.
05:15And then after it looks at the results, it will say, okay. Did I meet this done criteria? If no, I'm gonna act again, then observe again, and then reason.
05:22Otherwise, I'm gonna stop. And I'm gonna say, okay, mister or missus human, I am done. What's And really interesting is that the majority of tasks don't need loops.
05:29What I've started doing is for the majority of my tasks, will build some sort of loop, but it's just because of the verification. Right? This piece is so important, the verification loop.
05:38But a lot of times, you don't need some sort of massive agent architecture in order to run this sort of, like, dynamic looping workflow. You can just get it done with one simple terminal session and a good prompt.
05:48You can have this be just a solo loop, is what I'm typically doing the most. One agent that's reasoning, that's acting, observing, and repeating. And I'll show you guys some examples of what these loops might look like in just a sec.
05:57You can have a maker checker where you have one agent that does the thing and then one agent that grades the thing and gives feedback, or you can have this sort of manager with a bunch of helpers. And then as long as you've got one main agent that's orchestrating the whole thing, then you can build these loops in so many different ways.
06:11So let me just show you guys a few examples that I pulled. These first two that I'm gonna show you were actually from this loop library that Matthew Berman published. He created this loop library, which is a list of agent loops that you can use, and people can go submit their own.
06:23So kind of cool to just go in here and play around with and see what's available. And I grabbed two for these first two demos. So this was the first one right here.
06:30It was a slash goal prompt in Cloud Code to make me a thumbnail. So I told it basically what to use to make them. It says make 10 thumbnail concepts and score each one against mister beast YouTube thumbnails using a rubric, clarity at small size, curiosity, emotional pull, visual contrast, stuff like that.
06:45And after it makes those 10, it selects the top three. It identifies the weakest part of each concept. It improves them, rescores them, and then it continues iterating on on the strongest concept until it's satisfied.
06:55So that's one of the issues with this prompt here is that the definition of done was until you're satisfied. And sometimes you have to have these subjective sort of grading criteria, but you wanna get it objective as objective as possible.
07:08The best agent loops are where you literally say, keep iterating until x metric equals y result.
07:14But you can see right here what it did is it created 10. We've got number one. We've got number two, number three, number four, and number five.
07:20It ended up choosing that number one was one of the top contenders, number two, and so was number eight. So then it iterated on these. You can see here's number one original, here's number one v two, here's number two original, here's number two v two, and here's number eight original, and here's number eight v two.
07:35And what it did is after those version twos of all of it, it said, okay. Number eight's the best, So here is number eight v three. And so this is the final thumbnail that we got after we ran this goal, which took Claude code twenty seven minutes right there.
07:47So that's one quick example of the loop. You can see it was it was scoring each of these, and that's how it decided on the winner. But the one thing here is that these scores were subjective.
07:55So if we wanted to improve this flow, we would try to figure out how do we make this scoring more objective, and maybe what we would wanna do is create a separate sub agent that was a dedicated scorer, and we would prompt that scoring agent and run that through a bunch of evaluations so that we could feel more confident about its scoring ability.
08:11Anyways, let's take a look at the next one. So the next one was another slash goal. As you can see right here, this one took thirty seven minutes, and the prompt for this one was right here straight from Matthew Berman's loop library.
08:21I'm not gonna read this whole thing. You guys can pause it right there if you wanna see. But it was basically supposed to make a plane using three JS.
08:27So I'll open that up right here. We can see this is the spinning plane that it made. We can sort of zoom in.
08:31We can move it around, and that is what we got. Now from a looping perspective, what it had to do was it had to build it and then verify.
08:38Open up the browser, spin it around, see if it works, see if it's rendering properly, and then it kept iterating until we finally got this version. And as you can see still, like, it's not perfect. There's some things we wanna change.
08:48Change. I think it was supposed to be see through like this so we could, like, actually go look inside. But this is so much better than it would have been if I didn't give it that slash goal with the criteria, and I just said build me a three d plane with, you know, Three.
08:59Js. So that's one of the key takeaways here. Agent loops and goals are not supposed to give you a 100% perfect output.
09:05They're supposed to help you get much closer on the first try. And here's another great example of that with the whole subjectivity thing. Here's the last one I did, which is a a prompt that I had Claude code make, a slash goal.
09:15It was looking at this famous picture of the Beatles' Abbey Road, and then what I told it to do is recreate this without using image generation. So just recreating this using, like, HTML or CSS or whatever it wants to do, and then it goes through and it creates, you know, version one, version two, version three, and it ended up stopping after version seven.
09:32You can see the prompt here says, if the average is above nine or equal to nine, then stop, and that's when you end. The other thing it said is hard cap on eight passes, so it was getting near that cap either way. But these images are not very good.
09:44What we can see though is that it did its verification. So each time it went through and created the HTML, it had to actually put it in a browser, and then it would take a screenshot of it. You can see here's the screenshot for number one.
09:53Here's version two. Here's version three. Here's version four.
09:57So we can see it in real time getting better and better with each version, with each iteration. But still, this is the one that it gave me at the end, and obviously that looks nothing like the picture. We've got the car here.
10:06We've got the trees. We've got the road. We've got yellow, black, gray, light blue, just like the actual image if I go back here.
10:13Did I say yellow? I meant to say white. White, black, dark gray, light blue.
10:17And so, obviously, it's nothing like it. If we would have done this with image generation, it could have been probably much closer, but I just wanted to try how that would work with pure code. The point being, it had the verification checks.
10:27It had the ability to take screenshots and look through each of its iterations, understand how did this still not look like the reference image, and what changes do we need to make each time. And so that's why a loop is only gonna be as good as its done check, as the done criteria.
10:42So there's two things you need to think about before you build your first loop or your goals. What does done mean, and then how will it check? Because let's say you're building an actual game, a game that you can open up on your PC and play.
10:52It would have to check that in many ways. It would have to check visually. It would have to check functionally, and it would have to play the levels and see if anything breaks.
11:00If you're writing some sort of, like, script, how does it check? It doesn't need to check visually. It just needs to check flow.
11:05It needs to check that it sounds like your tone of voice. It needs to check-in other ways. So based on what you're building, the verification checks obviously look different, and it's your job to make sure that your agents have the right tools in order to do those checks.
11:17And then, of course, on the other side, what does done mean? Like I mentioned earlier, if you can get as objective as possible with a specific metric, then that's best. But sometimes you can't.
11:25Sometimes you have to say until you're a 100% confident. Right? And so, like, my most common use of these loops is when I use hyperframes and Claude code to edit videos because I will basically chuck it in, do a slash goal, and it does everything for me.
11:37It has to get the transcript, cut out the mistakes and the pauses. It has to make the beats. It has to sync the beats.
11:42It has to obviously render them, and then it has a ton of verification on making sure that all of the beats are inbounds and that they line up with the transcript correctly. And that is how you're able to see a lot of these people say, okay. I did this with one shot, with one prompt because it was a loop, because it had verification and iteration.
11:57So what makes a loop actually work? A checkable goal, a hard stop, good tools, memory, a separate checker, planning first, logging, and then making it make sense with the cost.
12:09Because a lot of times these loops can run for a long time, and especially if you have a pretty hard goal, a goal that might take a lot of iteration. And then if the done criteria is also very hard where maybe it just can't actually ever hit that, then that thing's gonna run for a long time. So I've had a couple loops that have gone for twelve hours plus, and they're just not, like, super useful to me.
12:29Most of the time when I'm running loops that run for a while, it's usually more like these. It's usually things that take, like, thirty five minutes or maybe a couple hours, but I don't need a loop that's gonna run for four days straight. I just don't really need that.
12:40So another kind of message that I'm trying to send here is just because you're seeing someone like Peter Steinberger saying something like this doesn't actually mean that this applies directly to you and your use case because he's a hardcore coder. He's building agents. He works at OpenAI.
12:55This probably makes a lot of sense for the way that he works and has probably 10 x ed his productivity. And that's the cool thing about AI is that it because it's going to seep into every single vertical and every single role, not everyone will use it the same. So it's good to stay up to date with what people like Peter Steinberger are saying, but that doesn't mean you have to drop everything right now and go try it.
13:12Or maybe it's good to try it, but that doesn't mean you have to fully integrate it into every single Cloud Code session forever. So, anyways, coming from a non coding background, coming from a perspective of someone who uses Cloud Code all the time twenty four seven, but I use it for knowledge work rather than massive database code base refactors and building software and building apps every day.
13:34That's kind of the way that I feel about these agent loops, and I've been seeing a ton of stuff about them lately, so I felt like I needed to come in here and just share my opinions on it. Some of you guys may disagree with this, but that's the way that I've been using them because I do use them. I just don't go for those fancy runs that run for, three days straight.
13:48A lot of times if I have a big goal, I will shoot off a nice chunky loop before I go to bed, and I can wake up with something that's ran for maybe four, maybe eight hours, and that is truly very beneficial. But a lot of that stuff is more experimental for me, and then I'm able to take that output I got from the overnight run and then chuck it back into some more loops or iterate on that myself as a human.
14:05So So there's a little bit more detail that was covered in this slide deck as well as this full audit, which is way more wordy and super ugly to look at. But I will attach both of these sources in my free school community if you guys wanna check all that out. The link for that is down in the description.
14:18You'll hop in the preschool community. You'll go to classroom. You'll click on all YouTube resources, and you can find everything in there.
14:23But that's gonna do it for today. So if you guys enjoyed the video or you learned something new, please give it like. It helps me out a ton.
14:28And as always, I appreciate you guys making it to the end of the video, and I'll see you on the next one. Thanks, guys.
The Hook
The bait, then the rug-pull.
The video opens on a screen full of Claude Code sessions all spinning at once — and immediately asks the question most people are too embarrassed to raise: is any of this actually useful, or is it just a flex? That pattern interrupt is the spine of the whole video, which spends fourteen minutes handing non-engineers a permission slip to think clearly about loops before copy-pasting someone else's hype.
Named ideas worth stealing.
02:23model
Reason -> Act -> Observe
The three-step loop cycle every agent architecture reduces to, regardless of how many agents are involved.
Steal forAny prompt engineering session where you want an agent to self-correct
02:54concept
Quality vs. Attempts curve
Visual showing that human-in-the-loop iteration climbs slowly; agent loops jump to much higher quality on attempt 1 and accelerate from there.
Steal forSelling the loop concept to stakeholders who think one-shot prompting is fine
10:31list
Done criteria taxonomy
- Functional — tests pass, app runs, build compiles
- Visual — something to be seen and judged
- Judgment — you write a checklist, score it against your rubric
- You decide — loop passes, you approve, continue
Four ways an agent can verify completion, from most to least objective.
Steal forDesigning any /goal prompt — pick the done-check type first, then write the goal
12:01list
What makes a loop work
- Checkable goal
- Hard stop
- Good tools
- Memory
- Separate checker
- Planning first
- Logging
- Cost awareness
8-ingredient checklist for building loops that actually finish and produce value.
Steal forPre-flight checklist before launching any long-running agent loop
How they asked for the click.
VERBAL ASK
14:06next-video
“I will attach both of these sources in my free school community if you guys wanna check all that out. The link for that is down in the description.”
Soft, community-first CTA delivered after a genuine content close. No hard sell. Directs to free Skool community to access slide deck and audit document.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
AFFILIATECommission earned if you click.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
