The man who built Claude Code doesn't prompt anymore
In June 2026, Boris Cherny, who leads Claude Code at Anthropic, said something that traveled fast through the AI scene: "I don't prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops."
That is more than a quip. It marks the handoff from one skill to the next. In the early years of mainstream AI use, prompt engineering was the central competency: the craft of getting the best first answer from the perfect input. After that came context engineering: packing the right things into the context window. Now the next term is on the table, and a month ago nobody called it this.
Loop engineering.
The term is exploding. Addy Osmani, LangChain, and Business Today are all writing about it, often inside the same week. This article opens the black box: what a loop really is, why engineering the loop is now the scarce skill, and what a production loop is actually made of. Explained so it lands even if you never write a line of code.
What is a loop, exactly?
A loop is a repeating cycle an agent runs to reach a goal without you directing each step. The base pattern is reason, act, observe, repeat.
Every round does the same thing. The agent thinks about what to do next (reason). It runs an action, such as a tool call, a command, a code change (act). It reads the result, meaning test output, error messages, logs (observe). Then it compares the state against the goal and decides the next round (repeat). It keeps going until a stopping condition triggers.
The root of this pattern is ReAct, short for reasoning and acting. It is the base most production systems build on.
Peter Steinberger, one of the loudest advocates of the idea, puts it bluntly:
You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents. — Peter Steinberger
The difference from a normal chat is simple: an answer machine hands you text once. A loop keeps working, checks itself, and corrects until the job is done.
That is exactly what separates a demo from a production system. An agent that generates code once can't catch runtime errors, can't adapt to the specific environment, and can't verify that what it produced actually works. The loop closes that gap.
Three eras: prompt, context, loop
The shift tells in three stages. At each one, the leverage moves further up, away from the single command, toward the system above it.
| App | Central question | Where the leverage is |
|---|---|---|
| Prompt engineering (first phase) | How do I phrase the perfect input? | The single prompt |
| Context engineering (second phase) | What belongs in the context window? | The information state |
| Loop engineering (2026) | Which system prompts the agent? | The design of the loop |
The point is not that prompt engineering is dead. You still need good prompts, good skills, good context. But the most expensive hour of your week no longer sits in polishing one sentence. It sits in designing the system that generates a thousand sentences, checks them, and improves them while you work on something else.
That is how a well-built loop multiplies a good professional. And that is what Cherny's line means: when the system writes the prompts, your work is the system.
The 6 building blocks of a production loop
A loop is not a magic model feature. It is built. Addy Osmani names six building blocks that turn a loop from a toy into a tool. Here without the jargon:
- Automations. The loop finds its own work, on a schedule or trigger. It doesn't wait for you to type. It starts in the morning and looks at what needs doing.
- Worktrees. Multiple agents work in parallel, each in its own isolated copy. That way one agent doesn't cut across another and overwrite its file.
- Skills. Project knowledge captured in files (in Claude Code,
SKILL.md). The agent doesn't have to relearn how your project works every time. - Connectors. Links to external tools through the Model Context Protocol (MCP). This lets the agent reach real systems, not just produce text.
- Sub-agents. A second agent checks the first one's work. Whoever builds shouldn't grade their own homework. That separation catches errors a single agent misses.
- State and memory. The loop writes its progress to a file, because models forget between runs. Tomorrow's run resumes where today's left off.
In Claude Code these blocks ship as first-party commands: /loop for recurring execution, /goal for a run that continues until a condition is met, /schedule for cron-based automation, plus the --worktree flag for parallel isolation.
The mistake that drains your budget
A loop without a clean stopping condition runs until the money runs out. It's the most common and most expensive beginner mistake in loop engineering. A production loop needs layered exits. First, a verifier that confirms the goal is truly met. Second, a hard cap on the number of rounds. Third, a token or time budget. And fourth, no-progress detection that halts when the state doesn't change across several rounds.
Loop engineering does not delete you from the equation
Loop engineering is tempting to read as an autopilot that makes you redundant. The opposite is true. Addy Osmani warns of three real risks, and they are why judgment is now the scarce resource.
Verification stays your job. The loop can check itself, but the definition of "correct" comes from you. An agent that confidently reaches its own wrong goal is more dangerous than no agent at all.
Comprehension debt grows. When nobody reads the generated code anymore, understanding debt piles up. Eventually a system runs that no one on the team understands. That bill arrives later, and it arrives expensive.
Cognitive surrender is the real danger. Loops can mask avoidance. Whoever no longer understands what is happening hasn't delegated, they've capitulated.
What this means for companies
Behind loop engineering sits a larger shift, and it touches every company, not just tech startups. Writing code became a commodity in 2026. What is scarce is the layer above it: the architecture, the thinking in goals and constraints, the orchestration of agents. The industry is shifting from coder to architect.
For a company that means something concrete: the bottleneck is no longer who types fast. The bottleneck is who can break a problem cleanly into goal, trigger, and verification step, so a loop can work it reliably. That is a different skill from classic software development, and today it is still rare.
Anyone in the company who still only types single prompts into a chat window is using a fraction of what's possible. The jump from answer machine to running loop is the same jump as from typewriter to program. From our base in Hamburg, IJONIS builds exactly these loops: we break a business process into a goal, give it a trigger and a verifier, and let it run while your team works on more important things.
If you want to rebuild the mechanics yourself, Anthropic and the Claude Code documentation describe the building blocks these commands sit on.
FAQ: common questions about loop engineering
Is loop engineering just another word for AI agents?
No. An AI agent is what runs inside the loop. Loop engineering is the discipline of building that loop: defining the goal, setting the trigger, adding verification steps and stopping conditions. The agent is the application, the loop is the system that drives it.
Do I need to code to build loops?
Increasingly not for the control itself. Tools like Claude Code ship loop commands (/loop, /goal, /schedule). The real skill isn't syntax, it's breaking a problem into goal, trigger, and verification step. That's closer to architecture than to typing.
What's the difference between prompt engineering and loop engineering?
Prompt engineering optimizes the single input for the best first answer. Loop engineering builds the system that generates many inputs, checks their results, and iterates until a goal is met. The leverage moves from the sentence to the loop.
Is this safe in production?
Only with guardrails. A loop needs stopping conditions (a round cap, a token budget, no-progress detection), a verifier, and human checkpoints before irreversible actions. Without those limits, a loop can run until the budget is gone. With them, it's a reliable tool.
Read next:
- AI Agent Harness: The Layer That Makes LLMs Productive: the software layer the loop runs in.
- How to Build an AI Agent: The 5 Parts, Explained: what a single agent is made of.
- Agent OS: Orchestrating AI Agents in the Enterprise: when one loop becomes many.
- Multi-Agent Systems in Practice: Architecture and Guide: how multiple agents work together.
