The Paradigm Shift¶
Stop writing prompts. Start designing loops.
Scope of this claim
This page argues for a class of work, not for a universal default. For recurring, well-specified, verifiable work — triage, sweeps, dependency bumps, docs sync, digests — a loop beats a person repeating themselves, and the payoff compounds. For building software, the dominant productive mode is interactive: "most effective coding agent use is a complex, highly iterative process" (Andrew Ng, 2026-09-04). Choosing Your Mode is the router between the two.
| Old way | Loop engineering |
|---|---|
| Prompt → wait → review → prompt again | Design the loop, then iterate on the loop |
| Tactical, one-shot | Strategic, systemic |
| You are the verification step | The loop verifies itself — and you verify the verifier |
| Session dies when you close your laptop | Loop runs on schedule or event trigger |
The second column used to read "design the loop once, let it run" and "the loop verifies itself", full stop. Both overstated it. A loop is a piece of software with an unusually unreliable component inside it; it needs the same iteration and the same review as anything else you ship. Ng's own three-loop model — carried in Human-in-the-Loop — has the developer loop firing every tens of minutes to hours, and his one first-party figure for unattended running is "around an hour."
The key insight — Boris Cherny, who built Claude Code, put it as "I don't prompt Claude anymore ... my job is to write loops", and Addy Osmani generalised it into the discipline's founding line: loop engineering is replacing yourself as the person who prompts the agent. Cobus Greyling frames the same replacement from the practitioner's side, spelling out the operational consequence: "stop being the person who prompts the agent. Design the system that finds the work, hands it out, checks it, remembers state, and decides the next step" — loops as "highly intelligent cron jobs," an "Agent Lite" alternative to building a full agent framework. (Cobus Greyling, "Loop Engineering is Agent Lite", Sep 2026.)
See The Factory Model for the deeper treatment: what the engineer's role becomes once implementation speed is no longer the bottleneck.
The same claim, made at company-building scale rather than individual-tool scale. a16z's Anish Acharya argues the shift this page documents for one engineer's workflow is also happening one level up — "how every job function becomes a loop" — framing loop design as a company-building skill, not just a coding-agent one. (Anish Acharya, Lenny's Newsletter, "Why companies are becoming a series of loops", Sep 2026.)
The June wave, dated — and the objection to it. Peter Steinberger's post went up on 2026-06-07 (18:58 UTC): "You should be designing loops that prompt your agents." The Register (Thomas Claburn, 2026-06-24, read in full) says the recent focus on loops "can be attributed in part to Peter Steinberger", even though "the likes of Andrej Karpathy were writing about and implementing AI loops months earlier" (Karpathy's autoresearch post is dated 2026-03-07). It carries the cost-incentive objection: Ed Zitron's reply, "Does OpenAI bill itself for its token spend?", and Claburn's own charge that the push is "celebrating and evangelizing autonomous token consumption" (see Cost Control). Gautham Pai's joke that LinkedIn would start a "Loop Engineering" fad drew Steinberger's reply the same day, "Don’t worry it’ll take 3 months until it’s there. We’ll be talking about fleets that design your loops then." The October exchange on whether it is over is in Context vs. Loop Engineering.
AI Leverage Formula¶
AI Leverage = Your Skill × Your Clarity
Where Clarity is your ability to articulate exactly what "done" looks like.
| Low clarity | High clarity |
|---|---|
| "Make the auth better" | "Fix the token refresh race condition described in ISSUE-42" |
| Produces plausible-looking output | Produces verifiable, targeted output |
| No stopping condition | The loop knows when to stop |
The formula implies two things: 1. You cannot outsource clarity — an agent given a vague brief produces vague work 2. Skill multiplies clarity — a skilled engineer's precise spec produces exponentially better output than a non-engineer's vague spec, even with the same model
(Sabrina Ramonov, "AI Loop Engineering", Jun 2026.)
Why Loops Beat Single Turns — The Compound Probability Argument¶
A task requiring 10 sequential correct decisions, each at 90% individual accuracy, has only 35% end-to-end success probability (0.9^10 ≈ 0.35). As tasks grow more complex, single-turn invocations fail not because the model is bad at any single step but because compound error rates make reliability impossible without a correction loop.
"The performance ceiling of any LLM-based system is not set by model quality — it is set by the quality of the loop surrounding the model." — @roanbrasil, "Loop Engineering: Designing the Execution Harness Around an LLM", Jun 2026
"A mediocre model inside a well-engineered loop outperforms a frontier model invoked once."
| Era | Paradigm |
|---|---|
| 2022 | f(prompt) → answer — single-turn, no correction |
| 2023 | Agent loop (LangChain era) — ReAct scaffolding, but unstable |
| 2024–2026 | Stabilised harness architecture — the loop is the primary engineering surface |
(@roanbrasil, "Loop Engineering: Designing the Execution Harness Around an LLM", Jun 2026.)
The New Software Lifecycle¶
AI agents have collapsed implementation speed. This changes where engineering effort concentrates:
| Old bottleneck | New bottleneck |
|---|---|
| Writing the code | Writing the spec |
| Implementation speed | Specification quality |
| Debugging your own code | Verifying agent output |
| Tool expertise | Harness design |
Engineers who thrive are those who excel at thinking at the right level of abstraction, specifying work precisely, and verifying output rigorously — not those who type fastest.
The same shift is described from the frontier-lab side as human work rising rather than vanishing. @karpathy writes that as models do more of the legwork autonomously, a lot more of our work will rise up the abstractions into oversight and understanding, and suggests asking the model for discardable custom artifacts (HTML pages, diagrams, bespoke explainer videos) to aid that understanding. In a longer post (@karpathy, a re-surfacing of an April post) he describes frontier-lab agent swarms collaborating over weeks and says human review and comprehension are starting to fall behind — a first-party data point for the comprehension-debt failure pattern, not a technique. For the attention cost of that oversight, see Development Workflow. (Both posts are opinion from one practitioner, Oct 2026.)
The harness and the spec are now first-class engineering artefacts. "Vibe coding" (accepting plausible-looking output without verification) is the new technical debt. (Addy Osmani, "The New Software Lifecycle", Jun 2026.)
Loop Engineering at Anthropic¶
Anthropic published five canonical agent workflow patterns that underpin their internal loop engineering practice:
| Pattern | Description |
|---|---|
| Prompt chaining | Sequential steps where each model call processes the output of the previous |
| Routing | A classifier determines which specialised sub-pipeline handles each input |
| Parallelization | Independent sub-tasks run in parallel; outputs are aggregated |
| Orchestrator-workers | A coordinator breaks the task down; worker agents execute sub-tasks |
| Evaluator-optimizer | Generator and evaluator alternate; evaluator feedback drives the next generation |
The evaluator-optimizer is the canonical implementation of the maker/checker verification loop: the generator produces an artifact, the evaluator judges it against defined criteria, and the result drives the next generation. The loop exits when the evaluator's criteria are met — this is loop engineering's stopping condition in practice. See Subagents for the DOER/CHECKER pattern and evaluator tuning.
(Anthropic, "Building Effective Agents", Dec 2024.)
A later first-party guide states the loop definition this page opens with as Anthropic's own official language, distilled from 13+ startups building on Claude Code: "Loops are agents that repeat cycles of work until a stop condition is met." The guide's worked example names a "Translucent code reviewer" agent and covers parallel subagents for adversarial review and git worktrees for isolated rebuilds — the same primitives this KB documents in Subagents and The Six Building Blocks, here as Anthropic's own recommended startup playbook rather than a community pattern. (Anthropic, "The Claude Code guide for startups", Sep 2026.)
A first-party worked example of the evaluator-optimizer shape with minimal human input between rounds (limited to the initial brief and occasional prompts to think more broadly): in Anthropic's account of designing quantum circuits with Claude, Claude proposes a circuit, a programmatic evaluator checks correctness and scores it, and the score feeds the next attempt; one run worked for 53 hours from a one-paragraph brief, told to explore several approaches in parallel. The verifier is code, not a model — the property that makes an unattended run of that length trustworthy. (Anthropic, "Designing more efficient quantum circuits with Claude", Oct 2026; read from the primary page, the figures are Anthropic's own.)
Who Benefits Most From the Shift¶
An analysis of roughly 400,000 Claude Code sessions found that domain expertise — not coding background — predicts how much work Claude does per instruction. This sharpens the AI Leverage Formula above: "Skill" was framed generically, but the data says the specific skill that compounds with Clarity is domain knowledge of the problem being solved, not general programming ability. A domain expert with limited coding background can write higher-leverage instructions than a strong general-purpose engineer working outside their domain, because clarity about what "done" means in this domain is what lets Claude do more per turn — the throughline back to the compound-probability argument above: fewer, clearer decisions per instruction compounds into fewer total turns needed. (Anthropic Research, "Agentic coding and persistent returns to expertise", Jun 2026.)