explainx / blog
Loop engineering is the practice of designing systems that prompt AI agents autonomously—rather than typing prompts yourself. Coined in June 2026, it represents the next evolution after prompt engineering for the agentic era.
Jul 7, 2026
On July 7, 2026, @ClaudeDevs published the definitive Claude Code loops guide by @delba_oliveira — how the team categorizes loops by trigger, stop criteria, and primitive. explainx.ai maps each type to real commands, skills, and the loop-engineering corpus you already have on-site.
Jun 19, 2026
If you need agent loops today, start at explainx.ai/loops — around 100 copy-ready workflows with kickoff prompts, guardrails, and new entries every week. Matthew Berman's Forward Future library is a similarly strong option with 26 practitioner-contributed recipes; here is how both compare and what early adopters like Theo (t3.gg) are running in production.
Jun 16, 2026
One week ago "loop engineering" was a term most developers hadn't heard. Today it is trending across X with 2,200+ posts, championed by Anthropic's Boris Cherny and OpenAI's Peter Steinberger, critiqued by Matt Pocock, and joked about by everyone who has watched Claude say "You're right to push back! I over-engineered this!" 87 times in a row. Here is the full picture.
In June 2026, a single quote from Boris Cherny—the creator of Claude Code at Anthropic—quietly reframed how developers think about AI:
"I don't prompt Claude anymore. I have loops that are running. They're the ones that are prompting Claude and figuring out what to do."
That shift—from you prompting the agent to a system prompting the agent—is what loop engineering is about.
June 30, 2026: Andrew Ng adds a product-building lens — inner agentic coding loops (minutes) nested inside developer feedback (hours) and external user feedback (days) when shipping 0→1 software.
Video course: Introduction to Loop Engineering (~1 hour on Udemy) — ReAct, reflection, tool-use, and multi-agent loops; Claude Code
/loopin Cursor; termination, memory, and guardrails. Course hub →
Loop engineering is the practice of designing the system that prompts your AI agent, rather than typing each prompt yourself.
Where prompt engineering asks: "What should I say to get the best output?"
Loop engineering asks: "What system should I build so the agent finds the work, does it, verifies it, and remembers what it did—without me in the loop at all?"
The term was popularized in June 2026 by Addy Osmani (engineering lead at Google Chrome), synthesizing ideas from Boris Cherny at Anthropic and Peter Steinberger (founder of PSPDFKit/Nutrient). The framing appeared across Osmani's blog, a Substack post, and a GitHub reference repository that quickly became a community standard.
The timing wasn't accidental. By mid-2026, AI coding agents had become capable enough to run multi-step tasks autonomously for hours. The bottleneck shifted from model capability to orchestration design. Developers who were still typing prompts one at a time were leaving 90% of the value on the table.
| Dimension | Prompt Engineering | Loop Engineering |
|---|---|---|
| Unit of work | One turn | Entire autonomous run |
| Who drives the agent | You, manually | A system you designed |
| Duration | Seconds | Minutes to hours |
| Output | A response | A verified outcome |
| Leverage | 1× | 10–100× |
| Skill required | Phrasing | System design |
Prompt engineering isn't dead—it's table stakes. Loop engineering is the next layer.
Every well-designed agent loop has the same five parts:
What starts the loop. This can be:
Without a trigger, you're still prompting manually. The trigger is what makes the loop autonomous.
A verifiable end state the agent works toward. Not "make things better"—but "all tests pass" or "zero open P1 issues" or "bundle size under 200KB."
Vague goals produce vague loops. The agent needs something it can check against. The /goal command in Claude Code is the clearest implementation of this idea: you define the completion condition upfront, and Claude iterates until it's met or the budget runs out.
The tools the agent can use inside the loop:
The actions define the surface area of the loop. Wider action sets mean more autonomy but more risk. Claude Code hooks let you intercept and gate these actions—running linting after every file edit, blocking dangerous commands before they execute.
How the loop knows when to stop. This can be:
Without verification, loops either run forever or stop too early. The supervisor architecture in Claude Code's /goal spawns an independent session to audit whether the primary agent actually achieved what it claimed.
What persists across iterations so the agent doesn't repeat work or lose context:
--continue, --resume) — reload a previous conversationMemory is what separates a loop that learns from one that spins.
Here's a concrete example—a morning triage loop:
Trigger: Every weekday at 8am
Goal: All GitHub issues labeled P1 have an assigned owner and a comment with a plan
Actions: Read GitHub issues (via MCP), write comments, assign labels
Verify: Check that zero P1 issues have no assignee
Memory: Log of issues already triaged this week
You set this up once. Every morning, an agent wakes up, pulls the issue list, triages anything unassigned, writes initial plans, and stops when the goal is confirmed. You review the results over coffee.
That's the leverage Boris Cherny was describing.
For a deeper implementation guide with Claude Code specifically, see: Loop Engineering: How to Design Coding Agent Loops That Run While You Sleep.
Building loops at scale requires more than just a good prompt. The key infrastructure layers:
Worktrees — Parallel agent runs that edit different parts of the codebase simultaneously need isolated working trees. Without them, two agents stepping on the same files creates corrupted state.
Scheduling — Whether it's cron, GitHub Actions, or Claude Code's built-in /bg command and Agent View, you need something that fires the trigger reliably.
Skills and CLAUDE.md — Loops that lack project context make bad decisions. CLAUDE.md files and skill definitions are how you encode what the agent should always know without burning context on it every turn.
MCP servers — Agents that can only read files are limited. MCP servers plug your agent into the external systems it needs: GitHub, Slack, your database, your CI system. See our guide on Claude Code MCP servers.
Observability — Long-running loops need logging. What did the agent do? Where did it stop? Why did it fail? Without observability, debugging a broken loop is guesswork.
The deeper implication of loop engineering is a change in where the developer's leverage lives.
In the manual prompting era, a developer who was good at phrasing got better results. In the loop engineering era, the leverage is in system architecture—the quality of the trigger, the precision of the goal, the design of the verification step.
This isn't about replacing developers. It's about elevating what developers do. As the Anthropic engineer's framing put it: the developer who builds the loop once gets compounding returns every time it runs.
The developers who thrive in the agentic era won't be the ones who write the best prompts. They'll be the ones who design the best loops.
If you want to go deeper on the practice side:
/loop in Cursor, guardrails, and failure-mode fixes