Agent Loops and Code

An agent loop is an AI that repeatedly reasons, acts, and observes results until it meets a goal. Think of it like a worker who figures out what to do, does it, checks what happened, then repeats until the job is done. The loop itself has three parts: a trigger (what starts the process), an action (the work the AI does), and a stop condition (how the AI knows it’s finished). The stop condition is often a clear, objective goal and a verification step to confirm the goal is met.

This matters because the best AI developers no longer write prompts—they design loops that automatically prompt the agent. Instead of you telling the agent what to do step-by-step, you build a meta agent that infers what loops you would want and runs them for you. This removes the human from the loop, allowing the AI to work faster and more autonomously. The key difference between a good and bad agent isn't the AI model itself—it’s what information the agent can read and how clearly the job is described. For example, a loop might keep checking, screenshotting, and reviewing until documentation is fully updated. By designing these recursive systems, you get your time back because the AI does both the thinking and the work.

An agent loop is an AI that reasons on what to do, acts on it, observes the result, and repeats until a goal is met. Think of it as a cycle with three parts: a trigger, an action, and a stop condition. Instead of manually prompting a coding agent each time, you design loops that prompt your agents for you. This shift—from human-in-the-loop to human-on-the-loop—turns Claude from a simple tool into infrastructure.

Here is a concrete example. Use Claude Code as your harness (the framework that runs the loop). Start with one main agent—your chief of staff. Give it a single sentence like "build a library website of agentic loop ideas." Claude reasons about the task, acts by writing code, observes the result, and iterates. If the first attempt isn't right, it doesn't start over; it continues the loop until done. One sentence can become 12 files because Claude understands the full scope.

Another pattern: have one agent that does the work and a second agent that grades the output and gives feedback. The main agent loops until the grader is satisfied. You can also set up a manager agent with helper sub-agents, all looping and calling each other. The key is to stop writing prompts for each step. Instead, define the loop—the trigger, the action, and the stop condition—and let the agent run until the documentation is fully up to date or the code passes review. You guide the conversation; you don't write the code yourself.

An agent loop is an AI that reasons, acts, observes the result, and repeats until a goal is met. The core pattern is "reason and act" (often called ReAct). Instead of you manually prompting an AI repeatedly, you design a loop—a system of three parts: a trigger (what starts it), an action (what the AI does), and a stop condition (when it finishes). Leading engineers like Boris Cherny and Peter Steinberg now say they never prompt coding agents directly; they write loops that prompt the agents for them.

A common pitfall is code bloat. When an agent's generated code exceeds about 1,000 lines, the loop often breaks because the AI cannot fully review and understand that much context. This leads to incorrect assumptions and wasted money on failed attempts. Another mistake is letting the agent make unchecked assumptions—when given freedom to guess, it usually gets it wrong and burns credits.

Best practices include designing loops that "pull until done" or "retry with back off" for reliability. For repeatable tasks, tell the agent to make a Python script and inject a description of that script back into the loop. The quality of an agent depends less on the AI model itself and more on what information the loop can read and how clearly the job is described—treat it like onboarding a new teammate with clear instructions and limited scope per iteration.