The 4 Types of AI Loops (and How to Pick the Right One)

Most people run their AI one prompt at a time. You type something, it answers, you check the answer, you type again. You are the trigger and you are the quality check, every single turn.

A loop moves one or both of those jobs into the system itself. Instead of you deciding when to run it and whether it’s good enough, the loop decides. You set it up once, hand off the babysitting, and it keeps going until the work is actually done.

That’s the whole shift. Ninety nine percent of people are still prompting their AI turn by turn. The one percent that gets real leverage out of these tools stopped doing that and started building loops instead. Here are the four types the Claude Code team actually uses, the real command for each one, and how to pick the right one for the task in front of you.

What a loop actually is

The old way looks like this: you prompt, it gives you an output, you check it, you prompt again. Over and over, and you never leave the loop yourself.

The new way is different. You define a goal, the agent does the work, then it checks its own output against that goal. If it’s not there yet, it keeps going, on its own, until the work is actually done.

Every loop, no matter which of the four types you pick, answers the same two questions: what starts a run, and what decides it’s finished. Once you can answer those two questions for a task, you can build the right loop for it.

Loop 1: Turn-based

This is the one closest to normal prompting, which is why it’s the easiest place to start. You still trigger it with a prompt. The agent acts, checks its own work inside that one turn, then hands it back to you to review before you write the next prompt.

The upgrade over plain prompting is small but it matters: you write a quick verification skill. That’s just a set of check-steps you save so the agent has to pass them before it hands the work back to you. Instead of you eyeballing every output, the agent is grading its own work against a rubric you wrote once.

Use turn-based when the task is exploratory. You don’t know exactly what “done” looks like yet, so you want to stay in the loop and steer each turn as you go. This is the right loop for anything where the requirements are still forming in your head as you see the outputs.

Loop 2: Goal-based

This is where it starts to feel different from prompting. You give the agent a stop condition, and it won’t quit until that condition is met, or until it hits a cap you set.

In Claude Code this is the /goal command. You type something like:

/goal get the bundle under 500kb or stop after 6 tries

Notice the cap is baked directly into the sentence, not a separate flag. That’s on purpose, and it’s the part people skip when they first try this. Without a stop condition, the agent will keep prompting itself indefinitely, trying variation after variation, and quietly draining your usage while you’re not watching. Put the cap in the same line as the goal, every time.

Use goal-based when the outcome is measurable but the path there isn’t worth your attention. You know exactly what finished looks like. You just don’t want to sit there and watch it get there.

Loop 3: Time-based

This one is triggered by a clock instead of a prompt or a condition. An interval fires, the agent runs a fixed task, then it waits for the next tick.

There are two ways to run it, depending on where you want it to live:

• /loop reruns the task on a timer while your session is open. Something like: check my latest PR every hour and fix whatever’s broken.
• /schedule does the same thing, but it runs in the cloud, so it keeps going even after you close your laptop.

Use time-based when the work recurs and the task itself is already known. You’re not deciding what to do each time, only when. If the only thing that repeats is the schedule, this is your loop.

Loop 4: Proactive

This is the most hands-off of the four, and it combines pieces of the other three. The difference is there’s no start button at all. A routine watches for an event or runs on a schedule with no human present, and when something needs handling, it spawns a small workflow on its own: a triage agent to figure out what happened, a fix agent to handle it, and a reviewer that checks the work before it’s marked done.

Think of it like an employee with a job description, not an assistant you have to brief every time. It knows the job. When something in its lane needs attention, it just does it.

Use proactive when you have a standing responsibility and you can’t predict what’s going to come in, only that something will. Inbox triage, PR review, incident response, anything where the trigger is an event rather than a clock or a prompt from you.

How to pick the right loop

Match the shape of your task to the loop, not the other way around:

• Exploratory, requirements still forming? Turn-based.
• Measurable outcome, but you don’t care about the path? Goal-based.
• Same known job, on a repeat? Time-based.
• Standing responsibility, unpredictable triggers? Proactive.

If you’re not sure where a task lands, start turn-based on one bottleneck task and hand off more control as you build trust in the outputs. You don’t need to jump straight to proactive on day one.

One more thing worth saying: not every task needs a loop. If it’s a one-off, just prompt it. Loops earn their setup cost on work that repeats or has to run without you sitting there. And whichever loop you build, always give it a verifier and a stop condition or cost cap before you walk away from it. That’s the difference between a loop that saves you time and one that quietly runs up your bill.

Your first loop

Pick one task in your workflow that’s a genuine bottleneck. Figure out whether it’s exploratory, measurable, recurring, or standing. Match it to the loop type above, set a clear done-condition and a cap, and let it run.

That’s the entire move: stop writing the next prompt, start designing the loop, and get out of the way.

If you want the exact setup for all four, including the verification skill and the cap syntax, we walk through it inside Actionable AI. You can also comment HANDOFF on the reel version of this breakdown and we’ll send it over directly.