From writing perfect prompts to designing self-running AI systems — why the best engineers now build loops, not chat sessions.
The Moment Everything Changed
June 7, 2026. Peter Steinberger, the developer behind the OpenClaw agent project, posted a single sentence that detonated across AI Twitter:
“I don’t prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops.”
6.5 million views in days.
The next day, Google engineer Addy Osmani published an essay titled “Loop Engineering” that gave the practice its name and anatomy: automations, worktrees, skills, connectors, sub-agents, and external state.
By mid-June, Boris Cherny — who leads Claude Code at Anthropic — confirmed the shift: “I don’t prompt Claude anymore.” When the people building the most-used coding agents say they’ve stopped prompting by hand, the practice has moved from fringe to mainstream.
Forbes covered it. Verdent AI analyzed it. MindStudio built visual tools around it.
This article is the field guide — not the hype version, the version you can use this afternoon.
What Is Loop Engineering? (For the Newcomer)
Loop engineering is the practice of designing the system that runs an AI agent in repeating cycles — instead of you typing every next instruction by hand.
The agent:
- Acts — writes code, calls a tool, queries a database
- Observes — reads the result, error, or output
- Reasons — decides what to do next
- Repeats — until a defined goal is met or a stop condition fires
You define the goal and the guardrails. The loop does the iterating.
The old way (2024): You write a prompt. The model responds. You copy the output. If it’s wrong, you prompt again.
The new way (2026): You write a loop. The agent runs for minutes or hours, self-correcting against real signals — test results, type checkers, runtime errors — while you make coffee.
New learners: Think of it like this — prompt engineering is teaching someone to answer one question well. Loop engineering is building a factory that answers questions, checks the answers, and improves itself while you sleep.
The Four Eras of AI Engineering: Where We Came From
Loop engineering didn’t appear from nowhere. It’s the latest layer in a steady migration outward:
Table
| Era | Year | What You Do | Your Role |
|---|---|---|---|
| Prompt Engineering | 2022–2024 | Write a good prompt, get a good output | Operator |
| Context Engineering | 2025 | Curate everything the model sees — docs, history, tool outputs | Information architect |
| Harness Engineering | 2026 | Build the environment — tools, constraints, feedback loops | Systems engineer |
| Loop Engineering | 2026+ | Design the cycle that runs the agent autonomously | System designer |
Each layer wraps the previous one. Prompts still matter. Context still matters. But the leverage moved up — from optimizing one input to governing a repeated cycle.
The Anatomy of a Well-Engineered Loop
A loop that runs unattended for an hour needs more than a goal and a model. Here are the pieces that separate reliable loops from runaway token fires:
1. A Clear Goal with a Testable Termination Condition
Good:“Make the test suite pass on the payments-refactor branch.” — Success is checkable. The loop knows when to stop.
Bad:“Improve the code.” — The loop never knows when it’s done. It will iterate until your budget runs out.
2. A Tool Set That Touches the Real Environment
The loop needs:
- File access (read/write codebase)
- Terminal access (run commands)
- Test runner (verify correctness)
- Type checker / linter (catch errors early)
- Version control (git worktrees for isolation)
The loop’s feedback is only as honest as the tools that produce it.
3. Context Management
Long loops overflow context windows. A well-engineered loop:
- Summarizes history instead of appending endlessly
- Prunes irrelevant past steps
- Offloads state to external storage (files, databases)
- Resets context periodically (the “Ralph Loop” pattern — more on this below)
4. The Verifier — The Most Important Piece
Here’s the insight that separates loop engineering from naive automation:
“In any loop, the verifier is the bottleneck, not the model.”
The generator (the LLM) produces code. The verifier decides if it ships, retries, or stops. A weak verifier doesn’t fail loudly — it confidently produces garbage hundreds of times. The verifier encodes your domain knowledge and taste, which the model cannot supply.
Types of verifiers:
- Deterministic: Tests pass, CI is green, type checks clean — unambiguous
- Heuristic: Code coverage > 80%, no new warnings — measurable
- LLM-as-Judge: A second model evaluates quality — flexible but expensive
- Human gate: Escalate to a human for risky actions — safest but slowest
5. Termination and Escalation Logic
Every production loop needs:
- Hard iteration cap — e.g., max 50 attempts
- Token/time budget — e.g., max $5 or 30 minutes per task
- No-progress detection — exit if the last 5 attempts produced identical errors
- Human escalation — hand off when stuck, don’t burn tokens forever
“Let the agent decide when it’s done” is the most expensive mistake in loop engineering.
Loop Patterns: From Research to Production
Loop engineering formalizes patterns that have been accumulating since 2022:
ReAct (Reason + Act) — The Foundation
The base pattern from Princeton/Google research (2022): interleave reasoning steps with action steps. The model thinks, acts, observes the result, then thinks again. Every modern loop is a descendant.
Reflexion — The Loop That Learns
Adds memory and self-critique. After a failed attempt, the agent writes a verbal lesson (“the patch failed because the import was wrong”) into an episodic memory buffer. Future attempts read this memory and avoid repeating mistakes. The loop gets smarter within a single session without retraining.
Plan-and-Execute — Divide and Conquer
Split a planner that decomposes the goal into ordered steps from an executor that runs them. Separating planning from doing reduces drift on long, multi-stage tasks.
Evaluator-Optimizer — Two Models, One Goal
From Anthropic’s Building Effective Agents: one model generates, a second evaluates against criteria and returns feedback. They cycle until evaluation passes. Best when you have clear, articulable acceptance criteria.
Orchestrator-Workers — Parallel Agent Fleets
A central orchestrator dynamically breaks tasks into subtasks, delegates each to a worker sub-agent (each with its own fresh context window), and synthesizes results. This is how overnight agent fleets are built.
Real-World Loop Engineering in Action
The Ralph Loop (July 2025)
Invented by Geoffrey Huntley. Deliberately simple, surprisingly effective:
- A coding agent runs inside an infinite shell loop
- Each iteration reads the same prompt file from disk
- The agent modifies the codebase and exits
- The loop restarts with a fresh context window
- State lives in the file system — codebase, TODO file, git history
Two problems solved:
- Context overflow — long sessions degrade as the window fills. The Ralph Loop resets context each iteration.
- Premature exit — LLMs stop when they subjectively decide the task is complete. A Stop Hook intercepts exit attempts, checks whether completion criteria are actually met, and reinjects the task prompt if not.
Claude Code /goal and /loop (May 2026)
Shipped in Claude Code v2.1.139. You set a completion condition, and Claude works autonomously across multiple turns until that condition is met — tracking elapsed time, turns, and tokens. A separate evaluator model checks whether the goal condition is met at the end of each turn. Early adopters called it “the most underrated AI feature of 2026.”
OpenAI Codex CLI /goal (v0.128.0)
Same concept, Codex-side. Sets a durable objective that survives session breaks. In one documented experiment: 25 hours uninterrupted, 13 million tokens, 30,000 lines of code.
Boris Cherny’s Parallel Loop Workflow
The workflow that made loop engineering visible to mainstream developers:
- 5 Claude Code instances in terminal, numbered by tab
- 5-10 Claude sessions in browser simultaneously
- System notifications to check in only when an agent needs input
- A “teleport” command to hand context between local and cloud
CLAUDE.mdas a persistent instruction layer every new session reads
The key insight: Every mistake an agent makes, the correction goes into CLAUDE.md. Future sessions don’t repeat it. The file becomes a cumulative record of project knowledge that survives context resets.
AI Jason’s Multi-Agent Loop System
Several loops share a brain via shared folders:
Table
| Loop | Trigger | What It Does | What It Writes |
|---|---|---|---|
| Support | Every 30 min | Answer tickets, spot friction | signals, engineer tasks |
| SEO | Daily, 9am | Research topics, publish pages | Pages, conversion-gap signals |
| Product Growth | Daily | Prioritize experiments | Tasks |
| Scheduled | Draft on-brand comments | Comment artifacts |
Because they share one file system, the SEO loop’s “this keyword converts but we have no content” signal feeds the content loop. The support loop’s repeated-bug signal gets picked up by the product loop. The shared brain is what makes it compound.
Loop Failure Modes: What Kills Loops in Production
Most loop disasters fall into a small set of recurring failures. Designing against them is most of what “engineering” means here:
Table
| Failure Mode | What Happens | The Fix |
|---|---|---|
| Context overflow and rot | Window fills, quality silently degrades | Compaction, pruning, sub-agent isolation |
| No-progress loops | Agent repeats the same failing action forever | No-progress detection + hard step cap |
| Objective misspecification (reward hacking) | Agent deletes failing tests to turn CI green | Termination criteria that capture intent + human gate on risky actions |
| Hallucinated success | Agent reports “done” without real verification | Trust deterministic verifiers, never the agent’s self-report |
| Compounding errors | Early mistake snowballs across trajectory | Verify early and often, not just at the end |
| Cost blowup | Long loops quietly burn tokens | Budget guards + prompt caching for repeated context |
Why This Matters for AI Engineers
1. The Bottleneck Shifted
When the model can write the code, the scarce skill is designing the cycle that keeps it correct and pointed at the goal. That’s a systems-engineering skill, not a copywriting one.
2. Reliability Becomes a Design Property
A one-shot prompt either works or it doesn’t. A loop that validates after every action turns a flaky generator into a system that converges.
3. Work Becomes Parallel and Asynchronous
Once an agent runs in a loop with its own worktree, you can run several at once and review results later. Throughput is no longer bounded by how fast a human can prompt.
The Verdict: Is Loop Engineering for You?
Table
| Use Loop Engineering When… | Stick to Interactive Prompting When… |
|---|---|
| Tasks are repetitive and long-running | One-off, creative tasks |
| Success is checkable (tests pass, CI green) | Success is subjective (“make it better”) |
| You can define clear stop conditions | The goal is exploratory and undefined |
| You have tools that provide honest feedback | You’re in early prototyping phase |
| You want agents running while you sleep | You need tight human oversight |
New learners: Start small. Build one loop that answers support tickets and logs frictions. Add a verifier that checks whether the answer actually addresses the ticket. Then expand. Loop engineering compounds — but only if the first loop is reliable.
Experienced engineers: The teams winning in 2026 aren’t the ones with the best prompts. They’re the ones with the best verifiers and stop conditions. Invest there.
Official Resources & Further Reading
Table
| Resource | Link |
|---|---|
| Addy Osmani’s “Loop Engineering” Essay | addyosmani.com |
| Anthropic’s “Building Effective Agents” | anthropic.com/engineering/building-effective-agents |
| Claude Code Documentation | docs.anthropic.com/claude-code |
| OpenAI Codex CLI | github.com/openai/codex |
| ReAct Paper (Yao et al., 2022) | arxiv.org/abs/2210.03629 |
| Reflexion Paper (Shinn et al., 2023) | arxiv.org/abs/2303.11366 |
| Verdent AI Loop Engineering Guide | verdent.ai/guides/agent/what-is-a-loop-engineer |
| MindStudio Loop Engineering Guide | mindstudio.ai/blog/what-is-loop-engineering-ai-coding-agents |
Your Turn: Build Your First Loop
This article is the starting point. The real learning happens when you ship.
Drop a comment and tell us:
- Have you built a loop yet? What was the goal, and did it actually stop when it was supposed to?
- What’s your biggest loop fear? Runaway costs? Hallucinated success? The agent deleting your codebase?
- Prompt engineering vs. loop engineering — where are you on the spectrum? Still crafting perfect prompts, or already designing autonomous cycles?
- What’s your verifier strategy? Deterministic tests, LLM-as-judge, or human-in-the-loop?
The most detailed war story, funniest failure mode, or most creative loop design gets featured in our next article — where we’ll connect loop engineering to observability (Helicone + Langfuse) and show you how to monitor, evaluate, and cost-control loops that run for hours unattended.
Subscribe to askgenai.in and join the conversation below. The best loop engineers learn from each other.
Next up: Loop Engineering in Production — tracing long-running loops with Langfuse, setting up evaluators that catch runaway agents, and the cost architecture that makes autonomous agents affordable.
Don’t miss it. See you in the comments.