Video of the Day1:59:26Sabrina Ramonov 🍄 · Tutorial
Loop Engineering, Claude Code /goal, and Agent Routines
A two-hour livestream that turns the year's biggest AI buzzword into a working autonomous agent you can ship this week.
June 19thThe argument in one line.
Loop engineering means removing yourself from the prompt-read-prompt cycle by building a system where a second AI checks the work and decides the next step, and Claude Code now ships all six pieces of that system — automations, worktrees, skills, connectors, subagents, and memory — built in.
Read if. Skip if.
READ IF YOU ARE…
- You already use Claude Code and want to move from typing prompts one at a time to letting an agent run a task to completion on its own.
- You have a task you repeat every week (inbox triage, a report, sorting files) and want to hand the whole loop to AI, not just one step of it.
- You want a concrete template for writing a /goal prompt with a real end condition instead of vague instructions.
- You're curious about Claude Code's Routines feature and want to see a scheduled agent connected to Gmail, Slack, or Intercom set up end to end.
SKIP IF…
- You're looking for a coding tutorial — this is explicitly no-code, aimed at using Claude Code's UI features, not writing scripts.
- You need enterprise-scale orchestration across many agents — this covers a single maker/checker pair, not a full multi-agent fleet.
The full version, fast.
Loop engineering is the practice of taking yourself out of the type-read-type prompting cycle by building a system that prompts the AI on a schedule or against a goal, then has a second AI check the work. The video names six ingredients — automations (schedule/trigger), worktrees (isolated lanes per agent), skills (a written Skill.md playbook), connectors (Gmail/Slack/Intercom access), subagents (a maker that does the work and an independent checker that grades it), and memory (a persistent file so runs don't start from zero) — and argues the hardest part is precisely defining what 'done' looks like. It then builds two live examples in Claude Code: a /goal prompt that sorts a messy Downloads folder into subfolders with a clear end state, a self-run check, and a guardrail capping it at 30 turns; and a scheduled Routine that reads unread email and DMs the three most urgent ones to Slack every morning. It closes with a real maker/checker pair — one agent closes support tickets via the Intercom API, a second agent independently re-verifies those closures two hours later and reopens anything that didn't actually solve the customer's problem.
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:36
01 · Intro: connecting three ideas
States the video is connecting three ideas — what loop engineering means, the /goal command with one copyable example, and building a first autonomous agent with a Routine — and that no coding is required.
00:36 – 01:38
02 · What loop engineering actually means
Defines loop engineering as building a system that prompts the AI for you instead of you typing each prompt and reading each answer; traces the idea back to appending 'don't stop until...' to a complex prompt.
01:38 – 04:38
03 · The six concepts: automations, worktrees, skills, connectors, subagents
Walks through automations (schedule/trigger-based runs), worktrees (isolated lanes so multiple agents don't collide), skills (a written Skill.md playbook), connectors (Gmail/Slack/Intercom access), and subagents (a maker that does the work plus an independent checker that reviews it).
04:38 – 05:26
04 · Memory and the hardest part: defining 'done'
Explains memory as a shared notebook on disk so each run isn't starting from zero, then caveats that defining what 'good' and 'done' look like — the checker — is the hardest part of the whole system.
05:26 – 06:38
05 · Pick a weekly task and write the sentence
Has the viewer write one sentence for a task they repeat every week: when it starts, what done looks like, and how the AI proves it's done — the raw material for a /goal prompt.
06:38 – 07:20
06 · Live demo: sorting the Downloads folder with /goal
Types a real /goal prompt — sort every file into subfolders by type, keep going until none are left, don't delete anything, stop after 30 turns — and Claude Code sorts 17 files into Images/Videos/Other folders in one pass, then verifies the counts itself.
07:20 – 08:09
07 · Goal achieved: what made this prompt work
Breaks down the three things that made the prompt good: a clear end state ('no loose files left'), a check the AI can run itself, and a guardrail ('do not delete anything' plus a 30-turn cap).
08:09 – 10:01
08 · Five intermediate /goal examples and the cheat sheet
Gives five more /goal templates — standardizing filenames, categorizing a spreadsheet, working through documents, cleaning up captions to brand rules, and turning ideas into hooks — then distills the pattern into a fill-in-the-blank cheat sheet.
10:01 – 11:07
09 · Building your first Claude Code Routine
Opens the Routines UI and configures a 'Daily Email Cleanup' routine: instructions to read unread email and Slack-DM the three most urgent, a guardrail not to reply to anything, a daily 9am trigger, and Gmail/Slack connectors.
11:07 – 11:55
10 · Routine results land in Slack
Runs the routine manually and shows the actual Slack DM it sent — the three most urgent unread emails, correctly timestamped — then notes an intermediate-level example: sorting and archiving thousands of unread emails on a schedule.
11:55 – 13:00
11 · A full maker/checker loop: support ticket cleanup
Introduces a real production routine pair: 'Daily Support Ticket Cleanup' (the maker, running at 8am via the Intercom API) and 'Daily Support Ticket Cleanup Checker' (a second agent that independently reviews the closures).
13:00 – 13:57
12 · Custom environments and API keys
Shows how to create a separate 'Support' environment holding an Intercom API key, explaining that the API exposes actions (like closing tickets) that the built-in Intercom MCP connector does not.
13:57 – 15:12
13 · The checker agent and the final cheat sheet
Configures the checker routine to run two hours after the maker, re-verify every ticket closed that day, and reopen any where the customer's problem wasn't clearly solved, then closes with Cheat Sheet 3 for building a routine from scratch.
Lines worth screenshotting.
- Loop engineering just means taking yourself out of the prompt-read-prompt cycle by having a second AI check the work and decide the next step.
- A loop only finishes reliably when it has three things: a clear end state, a check the AI can run on itself, and a guardrail capping how many turns it gets.
- The hardest part of any AI loop isn't the automation — it's writing a precise, checkable definition of what 'done' looks like.
- A maker agent that also grades its own work isn't a real check; the checker has to be a second, independent agent that can say 'not good enough.'
- Without a persistent memory file, every agent run starts from zero and repeats the same discovery work the previous run already did.
- Claude Code's /goal command defaults to a small, fast checker model (Haiku) rather than the model doing the actual work.
- A Skill.md file is a written playbook — naming conventions, constraints, and mistakes to never make — taught once and followed on every single run.
- Worktrees give each parallel agent its own lane so multiple agents editing the same project don't collide on the same files.
- A custom environment with an API key can unlock actions a built-in connector's MCP doesn't expose — Intercom's MCP can't close tickets, but its API can.
- One /goal prompt with a guardrail ('stop after 30 turns, do not delete anything') sorted 17 files into subfolders with zero manual checking.
- A real maker/checker loop runs on an offset schedule: the maker closes support tickets at 8am, and the checker independently re-verifies those closures two hours later.
- A Routine adds a schedule and connector permissions on top of the six loop-engineering concepts, turning a one-off /goal into a recurring agent.
- The safest way to trust a new routine is to start it read-only and let it summarize for a few days before granting it write/edit access.
The hardest part of an AI loop is writing the check, not the automation.
WHAT TO LEARN
An autonomous AI loop needs six specific pieces working together, and every one of them is useless without a precisely written definition of what 'done' actually looks like.
02What loop engineering actually means
- Loop engineering just means taking yourself out of the prompt-read-prompt cycle by having a second AI check the work and decide the next step.
- There have been informal versions of this for years — appending 'don't stop until...' to a complex prompt — but scheduled loops and independent checkers formalize it.
03The six concepts: automations, worktrees, skills, connectors, subagents
- Automations are the heartbeat: some kind of schedule or trigger that starts the agent without a human kicking it off each time.
- Worktrees give each parallel agent its own isolated lane so multiple agents editing the same project don't collide on the same files.
- A Skill.md file is a written playbook — naming conventions, constraints, mistakes to never make — taught once and followed on every single run.
- Connectors are what let an agent reach into everyday tools like Gmail, Slack, and Intercom to actually act, not just talk.
- A maker agent that also grades its own work isn't a real check; you need a second, independent agent whose only job is to say 'not good enough.'
04Memory and the hardest part: defining 'done'
- Without a persistent memory file, every agent run starts from zero and repeats the same discovery work the last run already did.
- Defining what 'good' and 'done' look like — the checker's job — is harder than it sounds and is the actual bottleneck in building any loop.
07Goal achieved: what made this prompt work
- A good /goal prompt needs three things: a clear end state, a check the AI can run on itself, and a guardrail that caps how far it can go.
- Capping the loop with an explicit turn limit ('stop after 30 turns') is what stops an unsupervised agent from running forever.
08Five intermediate /goal examples and the cheat sheet
- The fill-in-the-blank pattern for any /goal prompt is: what done looks like, checked by how, and stop after how many turns.
- The same three-part structure scales from tiny tasks (sorting a folder) to real production work (renaming invoices, categorizing spreadsheets, rewriting captions to brand rules).
09Building your first Claude Code Routine
- A Routine adds a schedule and connector permissions on top of the /goal pattern, turning a one-off prompt into a recurring agent that runs without you.
12Custom environments and API keys
- A custom environment with an API key can unlock actions a built-in connector doesn't expose — an MCP integration and the underlying API are not the same surface area.
13The checker agent and the final cheat sheet
- A real maker/checker pair runs on an offset schedule: the maker acts first, and the checker independently re-verifies the outcome afterward, not simultaneously.
- Start any new routine read-only and let it summarize for a few days before granting it write or edit access — trust the check before you trust the action.
Terms worth knowing.
- Loop engineering
- Building a system that prompts an AI on a schedule or against a goal, instead of a human typing each prompt and reading each response manually.
- /goal command
- A Claude Code feature that runs an agent repeatedly against a stated end condition, checking its own progress until that condition is verifiably met or a turn limit is hit.
- Routine
- A Claude Code feature that schedules an agent to run automatically (daily, weekly, or on a trigger) with a fixed set of instructions and connector access.
- Maker/checker loop
- A two-agent pattern where one agent (the maker) does the work and a second, independent agent (the checker) reviews it and can send it back if it isn't actually done.
- Worktree
- An isolated working copy of a project given to one agent so it can make changes without conflicting with other agents editing the same files.
- Skill.md
- A written playbook file that encodes an AI agent's conventions, naming rules, and guardrails so it behaves consistently on every run without re-explaining them.
- Connector
- An integration that lets a Claude Code agent use an everyday tool directly — such as Gmail, Slack, or Intercom — during a run.
- Guardrail
- An explicit constraint in a /goal or routine prompt, such as a turn limit or a 'do not delete anything' rule, that caps what the agent is allowed to do.
- Custom environment (Claude Code)
- A named set of environment variables (like an API key) that can be attached to a specific routine, giving it access beyond what its connectors alone allow.
Things they pointed at.
00:00toolClaude Code
10:30toolGmail (Claude Code connector)
10:30toolSlack (Claude Code connector)
12:21toolIntercom API
06:26toolClaude Haiku (default /goal checker model)
Lines you could clip.
00:13
“Loop engineering, all it really means is taking you out of that loop and building a little system that does the prompting for you.”
04:38
“Without some kind of shared notebook across all of your agents, every run would start from zero.”
05:30
“Defining what good and done looks like is the hardest part of creating the loop.”
04:05
“The reason why you want to have two separate agents is because one agent will do all of the work and the second agent will independently review it.”
13:00
“The intercom MCP does not allow me to close open tickets, but the intercom API does.”
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.
00:00Today, I'm gonna talk about loop engineering. We're gonna build your first autonomous agent using the concepts of loop engineering, using Claude code, the goal command, and routines.
00:10We're gonna talk about what loop engineering actually means, and then we're going to implement it for real using a Claude code goal command. And then we're gonna build our first autonomous agents by combining the concepts from loop engineering into a Claude code routine. Even though we're using Claude code, you do not need to know how to code.
00:25The only prerequisite here is setting up Claude code. So if you haven't done that, click on this link or go to my YouTube and search Claude code tutorial for beginners so that you can set it up. Let's just talk about what loop engineering means.
00:38So the typical way people do things is they prompt AI. It could be chat. It could be Claude.
00:43They type, they read the answer from AI and they type again. They read the answer from AI, you type again. So in that case, you are actually part of the loop.
00:52Loop engineering, all it really means is taking you out of that loop and building a little system that does the prompting for you. Meaning it checks the AI's work and then it decides what the next step should be. And when I say it, I mean another AI agent.
01:09So now we're going to have two AI agents. One doing the work and the other one doing what you would have done, which is review the work and then decide what the next step should be. There have been different ways to do this.
01:22Like, for example, I often will append this to the end of a complex prompt. Don't stop until dot dot dot. But now with Claude code goals and routines, there are more formalized ways that you can do this.
01:35There's six key concepts in what people are calling loop engineering today. So the first one is automations. So all we mean by automations is like there's some kind of schedule and then your AI agent runs and it completes certain tasks and it's running by itself.
01:52So instead of you sitting there every time and telling AI, here's what you should do, the loop is running on its own. It's running by itself on a schedule or you can trigger it with an external event.
02:05That's automation. The second part of the loop is called work trees. And this, the concept here is when you have many different AI agents and they're all working on the same project, they can easily conflict.
02:17So what you wanna do is give each agent its own lane. If you have like six agents all working on the same project, changing the same files, it's very likely to end up in a complete mess.
02:29What you want is different work trees for each agent. You don't actually have to implement this yourself. It's now part of Cloud Code and tooling.
02:38But conceptually, this is a really important concept because once you're orchestrating multiple agents, you want each one to have its own lane, its own work tree so it can safely make changes without disrupting the work of other agents simultaneously.
02:53Now concept number three is skills. You can think of them as a playbook. Let's say you reply to customer support tickets a certain way.
03:01You want a playbook that the AI agent can follow so it can consistently reply to customer support tickets the exact same way that you would. So a skill MD file just formalizes whatever your playbook is.
03:15For example, how you want to name things, the conventions you want the AI agent to follow, the mistakes that it should never make, any constraints or guardrails. You would include all of this in your skill MD file or your playbook.
03:30So you teach AI once and it will follow this playbook skill every single time. Key concept number four is connectors. You can think of this as AI being able to use the tools that you use every single day, such as Gmail, Slack, Intercom, etcetera.
03:47Connectors allow your agents to go implement the fix for you. Like, it'll fetch your code base, find the bug, try to fix it, add helpful comments, and check it back into your code base.
03:59So when you connect your AI agent to connectors, it can basically use all of the tools that you use. Concept number five in loop engineering is sub agents. This one is really important.
04:10So the easiest way to think about it is you have two agents, the one who's actually doing the work, the maker, and then a second agent, the checker.
04:19And the reason why you want to have two separate agents is because one agent will do all of the work and the second agent will independently review it. If the checker says, hey, this isn't good enough or this isn't ready yet, it's gonna tell the maker, here's why and here's what I think you should do next.
04:38So the final concept in loop engineering is memory. And you can think of this as like a shared notebook so that your AI agents on each run has context on what's been done, what else needs to be done, what should I do next. Now, practically, when you hook up Claude code to your GitHub repo or your GitHub project, that serves as a sort of memory.
05:01For example, in my social media posting project, my agent tracks like all of the posts it's made. Like, it has a little log file that tracks that.
05:10The reason this is important is without some kind of shared notebook across all of your agents, every run would start from zero.
05:20Like, it really wouldn't know what the previous agent has already accomplished, what blockers they're running into, and what it should do next. Yeah. I will caveat this.
05:28It sounds simple, but actually the hardest part is defining the checker. Let's take a social media post for example.
05:36How do you define what a good post is? Defining what good and done looks like is the hardest part of creating the loop. So now we're gonna dive into the actual practical part of this tutorial.
05:48So make sure you have Claude code open. The very first thing we're going to do, just think about a task you repeat every week. So when do you start the task?
05:57Is it a certain time of day? Is it when an email arrives? And then define what done looks like.
06:03So for example, in the morning at 8AM, I want to go through all my emails and label them accordingly, surface the three most urgent ones to my attention by DMing me on Slack. And then here's the check how the AI proves it's done.
06:18That would mean like every email, it has been labeled or archived. So think about this for one task that you repeat every single week.
06:27So here's how you type it. You just type slash goal, and it should turn blue. And then you can see here it's trying to help you with documentation, like what is the condition.
06:35You want AI to keep going until this condition has been met. So here's a simple example we're gonna do. Sort every file in my downloads folder into subfolders by type, keep going until no files are left, do not delete anything, and stop after 30 turns.
06:52Let's just paste this, run it and see what it does. So now it's found 17 files. It counted how many are in each category.
06:59Now it's creating the folders and moved everything turn by turn. Okay. And pretty much done.
07:04Found 17. Let me create the folders and move everything. All files moved, zero remaining at the top level.
07:11Now it's going to verify its work, verifying the counts. Done. Your downloads folder sorted.
07:16No files left at the top level. Nothing deleted. Okay.
07:20And then you could see goal achieved. Here is how, like, that prompt was structured. So Claude was moving each file at a time, checking what's left, and moves on to the next file and repeats.
07:29There were three things that made this, like, a good goal prompt. We have a clear end state. Right?
07:36Like keep going until no files are left. It had a check. It can run, right?
07:40Counts the loose files until it's still in the folder and a guardrail. Do not delete anything and stop after 30 turns. Here's our goal.
07:49Sort everything. Keep going until blank. This is the end condition.
07:55So when you type this, the small fast model, which is default haiku is going to check that no files are left. Like that's one of the goal conditions that it must check and these are constraints Like don't delete anything and stop after 30 turns. So here are five intermediate level examples.
08:12You don't have to run them right now, but I'm just giving you ideas of what else you can do. Standardizing a lot of messy files until every name matches a specific format. For example, I have a ton of invoices and receipts, so you can rename them all in this particular format in date order and keep going until no file has its original name.
08:33Do not delete or move anything and stop after 25 turns. So this is one example. The end state here, like what is the goal condition that our checker agent can verify?
08:43We have zero files left with the old style name. Practical example number two, categorizing a spreadsheet until no row is missing a label. Here's practical example number three, working through a stack of documents until none are left.
08:58Practical example number four, cleaning up a bunch of social media captions until they fit all of your brand voice rules. And then this one is turning a list of rough ideas into hooks until the list is done. Turn each of these ideas into hooks.
09:12Keep going. Don't change other files and stop after 30 turns. Here's the cheat sheet number two.
09:18So this is just generally the framework to think about when writing your goal prompt slash goal. What done looks like checked by how, like how do you prove it? Is it account?
09:30Is it that all of your tests pass? Is it that you're you have zero bugs in this area and stop after x number of turns?
09:39So practice that. Like, try it with some of these examples. You can tweak them so it makes sense for your use case or industry, but like really get in the hang of thinking in this way.
09:49You want to think in terms of loops where there is a verification step in the task itself. Cause a lot of people actually don't ever add a verification step. Now we're going to build our first autonomous agent with a Cloud Code routine.
10:04Okay. So click new routine and then you should have a form that looks like this. This is the name of your routine.
10:10These are the instructions. We're going to read all of your unread emails, figure out the three most important ones, and send a Slack message to myself. And do not reply with anything.
10:19This is the constraint or guardrail. This is where you can select the project. This is where you select the model and this is the trigger.
10:24When do you want this loop to run? Just click schedule and then run daily at 9AM.
10:30You can edit this as well. And then connectors here is what this loop will have access to. So remember, one of the key concepts of loop engineering is connectors, the ability for your AI agent to use the tools you use.
10:43For this example, we're just going to use Gmail and Slack. To add connectors, you can click add connector here. And we will cover how to add tools that don't have these nice connectors.
10:53Click save, so then you'll have it here. This is where you'll see all of the routines you have running. So obviously, you just created this one.
11:00You can test it by clicking run now. You can actually click this to expand it and see what it's doing. Okay.
11:06So that one finished running. So you can see check mark here today at 12:44PM. So let's go to my Slack.
11:13Here are my top three unread emails. You can see the timestamp is literally right now. Someone sends a long book excerpt.
11:20So these are my top three most urgent emails. It was sent to my Slack. Okay.
11:24And again, you can open the conversation here. You can continue the conversation if you want to update anything and you can update the routine itself. So once you create it, it's kinda gonna look like this.
11:34Click this pencil button in the top right corner if you wanna go ahead and update it again. Here's some intermediate level examples. Let's say you do have like thousands of unread emails.
11:44It can completely sort your inbox, label every single email, and archive the ones you don't want. Okay? So you can set that up as a routine running on a daily or a weekly basis.
11:55Now I'm gonna show you a real example of a Claude code loop including the main agent that does the work and the checker agents that independently reviews the work. So it's gonna be these two. This one day every day runs at 8AM and cleans up support tickets and also surfaces any issues and gives product roadmap recommendations.
12:13This is the checker. So it will review all of the closed tickets that were closed by this agent and confirm they should have been closed. So here's what this looks like.
12:23So it's actually not that much longer, but it utilizes different things. I have a skill already in this GitHub project.
12:30By the way, this is where you can add your GitHub projects. So run the cleanup ticket skill on all open customer support tickets using the intercom API. Provide a summary in Slack hashtag support channel.
12:43And when referencing conversations, always provide the full link so I can easily click and open it. Do not delete tickets.
12:50Here are constraints and guardrails, and do not stop until you've processed all currently open tickets. Here's the trigger.
12:56This runs daily at 8AM. And then here are my connectors, intercom, and Slack.
13:01In this routine, I also actually have an API key. So what you can do is you can create a separate environment that stores like your environment variables.
13:12So the default environment for me does not have any environment variables, then my support environment contains my API key for intercom. And the reason for that is using the intercom API, I have access to a lot more things than using the intercom MCP. For example, the intercom MCP does not allow me to close open tickets, but the intercom API does.
13:36So for those of you who are feeling limited by connectors or you wanna integrate an API that doesn't have a connector, you can just create a new environment like click add environment and then you can put your environment variables here. So let's say this is our research environment and we wanna put our perplexity API token equals and then put the token here.
13:58This is the maker agent, so the primary one doing the work, classifying tickets, analyzing them, and then I have the checker agent here. So this will run about two hours after the other one and its job is to independently verify all of the support tickets that were automatically closed today.
14:16Confirm that each ticket should remain closed. If the support responses received by a customer do not clearly solve their problem, reopen the ticket. So again, in loop engineering, the concept here called it sub agents.
14:29One primary agent to do the work and another agent to verify the quality and accuracy of the work. So this is the checker agent that helps verify it. So it's set up similarly.
14:40The only difference really is it runs two hours after the first one runs because the first one takes a while to actually process all of those tickets. So here's the cheat sheet number three. Think about when should it run?
14:50What is the trigger? What should it do, fill that in here, what are the tools it needs, connectors and API.
15:00Make you can make a list here. And what is the limit that you want it to have? Like, don't reply to emails or don't delete something.
15:07Think about this cheat sheet and fill it out, and this will help you create the Claude code routine.
The Hook
The bait, then the rug-pull.
The pitch is blunt: most people using AI are still part of the loop themselves, typing a prompt, reading the answer, typing again. This walkthrough shows what changes when a second AI takes over that checking role — and then builds two working examples, live, using nothing but Claude Code's /goal command and its new Routines feature.
Named ideas worth stealing.
01:38list
The Six Concepts of Loop Engineering
- Automations
- Worktrees
- Skills
- Connectors
- Sub-agents
- Memory
The full inventory of what an autonomous AI loop needs: a schedule/trigger, isolated lanes per agent, a written playbook, tool access, an independent verifier, and persistent state.
Steal forauditing any AI automation idea for the piece it's missing before building it
07:40list
Three Things That Make a Good /goal Prompt
- A clear end state
- A check the AI can run itself
- A guardrail
The minimum structure for any prompt meant to run unsupervised to completion, demonstrated on the Downloads-folder sort.
Steal forwriting any 'keep going until X' prompt, not just in Claude Code
05:26model
The Weekly-Task Sentence (Cheatsheet 1)
- Starts when: (a time of day, or an event arriving)
- Done looks like: (the observable end state)
- The check: (how the AI proves it's done)
A fill-in-the-blank sentence for turning any repeated weekly task into the raw material for a /goal prompt or a routine.
Steal foridentifying the first task worth automating before touching Claude Code at all
How they asked for the click.
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
