Loop Engineering

Loop Engineering is a new concept that spread rapidly in the AI programming community in June 2026. It was systematically organized by Google engineer Addy Osmani, and Anthropic Claude Code lead Boris Cherny and developer Peter Steinberger both publicly proposed the same viewpoint.

This article will guide you from zero to understand what Loop Engineering is, its essential differences from Prompt Engineering, the six key elements that constitute a complete Agent Loop, and how to design your first runnable Loop.

The Evolution of AI Engineering

Over the past two years, the focus of AI development has been constantly shifting: from researching how to write good prompts, gradually evolving to organizing context and orchestrating tools and workflows (Harness), and then to building loop systems (Loop) that can run autonomously and continuously deliver results.

Prompt：怎么问 AI
↓
Context：给 AI 什么信息
↓
Harness：如何组织 AI 的能力
↓
Loop：如何让 AI 持续创造结果

The Origins of Loop Engineering

Loop Engineering emerged at a clear point in time: June 2026.

The Tipping Point: Two Sentences, Millions of Shares

In early June 2026, the head of Anthropic Claude CodeBoris Chernysaid in a public speech:

"I don't prompt Claude anymore. I have loops running. They're the ones prompting Claude and figuring out what to do. My job is to write loops."
(I no longer prompt Claude directly. I have a set of Loops running that prompt Claude and decide what to do next. My job is writing Loops.)

A few days later, on June 7, 2026, developerPeter Steinberger—creator of the open-source AI Agent project OpenClaw (the fastest-starred new repository in GitHub history)—posted a twelve-character tweet:

"You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."
(You should no longer manually prompt AI coding assistants. You should design Loops that let Agents prompt themselves.)

• Prompt Engineeringis "teaching AI how to do things"
• Loop Engineeringis "designing a system where AI continuously does things itself"

These two sentences sparked huge discussion in the AI developer community because they precisely described a trend that many had felt but not yet named:Whether prompts are well-written is no longer the bottleneck; the bottleneck lies in the entire running system you design for the Agent.。

Subsequently, Addy Osmani published a long article on Substack, formally naming and systematizing this practice asLoop Engineering, making it an independent engineering discipline.

Background: Three Generations of AI Programming Tools

Loop Engineering did not come out of nowhere; it is the natural result of the evolution of AI programming tool capabilities.

The emergence of third-generation tools means that an engineer's core competency has shifted from writing prompts to designing Loops.

What is Loop Engineering

Loop Engineering is the engineering practice of designing, operating, and continuously improving feedback loops that enable AI coding Agents to autonomously plan, execute code modifications, observe results, and complete tasks across multiple iterations.

In one sentence:

Loop Engineering turns you from "the person who prompts the Agent" into "the engineer who designs the system that prompts the Agent."

What is a Loop

A Loop is a recursive goal system: you define a purpose, and the Agent iterates until the work is truly done.

Every Agent already has a built-in "inner loop" when executing tasks: Perceive → Reason → Act → Observe, then loop again.

Loop Engineering works at thenext level above：

You no longer sit beside the Agent, typing a command for every step. You are designing an external system that drives the inner loop for you, while you do the things that require more judgment.

The Difference Between Loop Engineering and Prompt Engineering

Prompt Engineering is not dead. A Loop is composed of multiple Prompts, and poorly written Prompts placed into a Loop only produce bad work at a faster rate. Loop Engineering is a layer above Prompt Engineering, not a replacement for it.

The full three-layer technical stack:

The Core Loop

The foundational structure of an Agent Loop consists of five stages connected end-to-end, iterating continuously.

The power of a Loop lies not in any single step, but in theclosed loop. A test failure is not just an error message; it is new context. A type error is not just a blocker; it is a signal about a wrong assumption. A Code Review comment is not just feedback; it is a new observation driving the next action.

Six Core Components

A Loop that can truly run independently requires five core components, plus a memory system that runs throughout. None can be missing.

Component 1: Automations

Automations are the heartbeat of a Loop. Without automatic triggering, a Loop is just "an operation you did once," not a true cycle.

Triggers define:When? Do what?

In Claude Code, use/loopcommand to create a scheduled Loop:

In OpenAI Codex, Automations has a dedicated UI panel where you can set the project, prompt, cadence, and whether to run in a local checkout or a background Worktree. Runs that find content go into a Triage inbox; runs that find nothing are archived automatically.

Token cost warning:Scheduled Loops with verification sub-agents consume tokens on every trigger, and consumption varies significantly with task complexity. It's recommended to start with a slower cadence (e.g., once a day), observe costs for a few days, then increase frequency.

Component 2: Parallel Isolation (Worktrees)

When you run multiple Agents at the same time, file conflicts are the most likely source of problems. Two Agents writing to the same file simultaneously is like two engineers committing to the same line of code—the result is catastrophic.

Git Worktreeis the solution: give each Agent its own working directory, operate on separate branches, share the same Git history, but keep file changes completely isolated.

Worktrees eliminate mechanical file conflicts, but they cannot eliminatethe review bottleneck. The speed at which you process and approve code changes is the real ceiling on how many Agents you can run in parallel, not how many Worktrees the tool can open.

Component 3: Skills Files

Skills (skill files) address a cost that is wasted every time:With every new conversation, the Agent has to infer your project conventions from scratch。

A Skill is a package containingSKILL.mdThe folder of files, which documents project conventions, build steps, and knowledge like "we don't do it this way because of that incident". The Agent loads the Skill at the start of each session instead of re-guessing every time.

Component 4: Connectors / MCP

A Loop that can only see the local filesystem can do very limited things. Connectors (based on MCP—Model Context Protocol) enable the Agent to read issue trackers, query databases, call APIs, and send messages in Slack.

This is the core difference between "the Agent saying 'here's the fix'" and "the Loop automatically opening a PR, linking the ticket, and notifying the channel after CI passes."

Both Claude Code and OpenAI Codex natively support the MCP protocol, and connectors written for one tool can generally be used in both.

Connecting connectors to the Agent means it can take real actions in real environments. Each connector must be configured with least privilege, and high-risk operations (pushing code, merging PRs, sending external notifications) must require human approval; they cannot be executed fully automatically.

Component 5: Sub-Agents

One of the most important architectural decisions in the Loop:Separate the Agent that writes code from the Agent that checks code。

The model that wrote the code is too lenient when grading its own work. An independent checker with different instructions—sometimes using a different model—can catch problems that the first Agent rationalized away.

This "Maker-Checker" pattern is also applied to the Loop's stopping condition: Claude Code's/goalcommand uses a separate model after each iteration to judge whether it is "done", rather than letting the model that did the work make that judgment.

Component 6: Persistent Memory

Memory is the core pillar of any Loop that can run persistently across conversations.

The model completely forgets between conversations. Without external memory, every time the Loop triggers, the Agent starts from zero, not knowing what was done yesterday, which fixes have been merged, and which tasks are still open.

The solution is extremely simple:Write state to files, and keep the files in the repository.. The repository remembers even if the model does not.

Five Common Loop Patterns

Different types of tasks require different feedback signals and stopping conditions, therefore several classic Loop patterns have emerged.

Building Your First Loop

Don't try to build a fully automated, multi-agent Loop that auto-merges PRs from the start. Start with the smallest usable Loop, understand its behavior, then gradually expand.

Step 1: Start with a Narrow Task

The narrower the task, the clearer the Agent is about which files matter and which validation signals are relevant.

Step 2: Clearly Specify the Verification Method

The Loop needs to know what "done" means. If you know the verification command, write it directly into the instructions.

Step 3: Set Up Safety Mechanisms

Before the Loop can automatically open PRs, have it only write files and perform no external actions; you review the diff and decide whether to commit.

This minimal version of the Loop is already valuable: it organizes yesterday's issue list for you every morning, and when you get to the office you can open TODO.md and know what to do today instead of spending half an hour digging through CI logs. This is the best starting point for understanding Loop behavior, with almost zero risk.

Step 4: Gradually Increase Autonomy

Three Major Risks of Loop Engineering

Loop changes the way you work, but it doesn't eliminate the engineer's responsibility. There are three problems that become more severe as Loop improves, not easier.

Risk 1: Verification Remains Your Responsibility

A Loop that runs unattended is also a Loop that makes mistakes unattended. Setting up a reviewer sub-agent is a good way to reduce risk, but "passed verification" is a claim, not proof.

No matter how reliable the Loop is, human review of merged code cannot disappear.

Risk 2: Comprehension Debt Accumulates Faster

The faster Loop produces code, the lower the proportion of code you actually understand. This isn't a problem unique to AI programming, but Loop has accelerated it.

The only antidote is:Read the code Loop producesDon't stop understanding what it's doing just because Loop runs smoothly.

Risk 3: Cognitive Surrender

When Loop runs automatically, accepting whatever result it returns is the most comfortable choice. This is the most hidden danger of Loop Engineering.

Two people can build exactly the same Loop yet get completely opposite results: one uses it to advance faster on the basis of deep understanding, the other uses it to avoid the work of understanding itself. Loop doesn't know the difference. You do.

Four types of Loop failure modes and countermeasures:

Best Practices Summary

The following are core principles for building reliable Loops; each corresponds to a common class of failure.