What Is an Agent Loop? Claude Code Guide

When an agent works through a complex task, writing code is only half the job. The harder part is managing the loop it runs in. An agent loop is the cycle an agent goes through to finish a task: think, act, observe the result, verify itself, and repeat until a stop condition is met. Claude Code's /loop feature is a concrete expression of that idea in the tool I teach every day.

What an Agent Loop Actually Is

An agent loop is think, act, observe, verify, repeat, until a gate or stop condition passes. The difference from a single prompt is fundamental: an agent does not answer once and stop, it keeps going until the task is genuinely closed. Simple example: you tell it to fix the tests, and it runs them, sees a failure, fixes it, runs again, and repeats until they are green. That is a loop. The agent is the unit of work, and the loop is what turns it from a one-shot answer into a worker that finishes a job.

Primary source: How Claude Code works

Why the Loop Became the Bottleneck

Prompt engineering was about how to phrase one request perfectly. But when the agent runs in a loop, quality is decided by how the loop checks itself, which is the verifier. If the agent does not know when it is done or when it made a mistake, it gets stuck, hallucinates, or runs in circles. In practice, the expensive failures start when the loop cannot recognize an error or stop. An agent with no reliable way to verify itself is a dangerous agent.

Loop Engineering: From Prompt to Loop

Instead of pouring all the effort into one perfect request, loop engineering focuses on designing the loop itself: what the goal is, what the stop condition is, how you verify progress each pass, and when a human steps in. Four things I check in every loop I build:

• A clear stop condition (gate): without it the loop never knows when to finish, the most common cause of an agent running off the rails
• A real verifier: tests, a build, or a review agent that checks the output before it moves on
• Open vs closed loop: human-in-the-loop approval at critical points, or full autonomy only when verification is strong
• A narrow scope: too broad a loop stalls, a focused loop converges fast

Claude Code /loop: The Idea Inside the Tool

Claude Code /loop runs a prompt or command on a recurring interval. The command /loop 5m /tests runs the tests every five minutes. With no interval, Claude chooses the cadence for each iteration. Recurring tasks expire seven days after creation. They only fire while Claude Code is running and idle; if you resume the same conversation with --resume or --continue before expiry, the unexpired task is restored. That makes /loop useful for session-scoped polling such as watching a deploy, babysitting an open PR, or running periodic checks. For automation that must survive independently of a session, use Routines, Desktop scheduled tasks, or GitHub Actions.

Primary source: Run prompts on a schedule

From My Own Production Experience

This week I built an automated blog pipeline that runs in a loop: every Tuesday and Friday it generates a Hebrew draft, builds the site, opens a PR, and sends me a WhatsApp message. It is a loop with a human gate, I approve by merging. That is loop engineering in miniature: the goal is clear, there is a real verifier (if the build fails, there is no PR), and there is a stop condition (my approval). The most important lesson: the longer and more autonomous the loop, the stronger the verifier has to be. Without it you are not saving work, you are only deferring it.

The people who get the most out of this wave are not the ones who write the best prompt, but the ones who design the best loop: with clear stop conditions and checks that catch mistakes before they compound.