Anthropic’s Worst-Kept Secret

How to read this: Sections 01-03 are the ground truth (what a loop is and where it runs). Section 04 is the decision tree you’ll actually screenshot. Section 05 is the money. Section 06 is ours. Section 07 is the part most guides skip: how loops go wrong. Sources for every claim are in Section 08.

For two years the skill everyone chased was writing the perfect prompt. Then the guy who built the most successful coding agent on the planet said the quiet part out loud.

“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.”

Boris Cherny, Head of Claude Code, Anthropic · June 2026

Everyone clipped that line. Almost nobody unpacked it. Around the same time, Peter Steinberger (the OpenClaw creator) put it more bluntly: you shouldn’t be prompting coding agents anymore, you should be designing the loops that prompt your agents. On June 7, Google’s Addy Osmani gave the pattern its name in a post that went everywhere: loop engineering. Replacing yourself as the person who prompts the agent, and designing the system that does it instead.

Now the source behind the rhetoric, quoted precisely because the sloppy version is already circulating: Anthropic’s internal version of Claude Tag lands 65% of their product PRs. Not “65% of all code everywhere.” Their agent, their codebase, their PRs. Still a staggering number, and it comes with a telling side effect: Anthropic reports code output per engineer up roughly 200% this year, which made human review the bottleneck, which is why they built automated review agents that dispatch on every PR. Loops created the bottleneck. Loops then got pointed at the bottleneck. That recursion is the whole story of 2026.

Where loops came from: a bash one-liner

Before anyone called it loop engineering, there was Ralph. In July 2025, Geoffrey Huntley published the technique: run a coding agent inside a plain while loop, feeding it the same prompt file every iteration.

# The original Ralph loop (sandbox only, obviously)
while true; do
cat PROMPT.md | claude --dangerously-skip-permissions
done

Named after Ralph Wiggum: not the sharpest tool in the shed, gets there through sheer persistence. Huntley calls it “deterministically bad in an undeterministic world,” and that’s a feature. Each iteration starts with a fresh context window, because model quality measurably degrades as context fills (practitioners put the drop-off somewhere past 100-150k tokens, the “Dumb Zone”). State lives in the file system instead of the conversation: a plan file, a changelog, git history. The loop is dumb. The system around it isn’t. It works well enough that peer-reviewed papers now cite Ralph loops as methodology for multi-hour unattended runs.

So the arc looks like this: prompt engineering (2023) taught us to write the instruction. Context engineering (2024-25) taught us to feed the model the right material. Loop engineering sits one floor above both: the autonomous control structure that decides what to prompt, when, and whether the result is acceptable. The lower layers didn’t disappear. A sloppy prompt inside a loop just produces sloppy work faster.

Most loop disasters aren’t runaways. Runaways are easy, you notice the token burn. The dangerous loop is the polite one: it exits clean, hands you something confidently structured, and fixed exactly nothing.

The five components, and where the leverage hides

Trigger starts the loop: a timer, a git event, a CI signal, a schedule. Find work is discovery: the backlog, the failing checks, the unreviewed diffs. Execute is the agent attempt, ideally with fresh context per iteration (the Ralph rule: don’t hoard the primary context window, spawn subagents). Verify is the multiplier, and we’ll get to it. Record writes state somewhere durable so the next iteration, or next week’s loop, doesn’t rediscover everything: a state file, git, and crucially, lessons. Cherny’s first rule of running agents is that when the model makes a repeated mistake, the correction gets written into CLAUDE.md or a skill. Correction becomes durable instruction becomes better future runs. That’s the loop learning without any training run.

The two gates

A stop condition says the loop ended: iteration cap hit, promise string emitted, timer expired. A success condition says the work is right: checks pass, the output was graded, the claim was proven. These are completely different problems, and conflating them is the number one design error in the wild. One practitioner in the loop engineering threads described a triage loop that exited clean and fixed exactly nothing. Write both gates. Grade the output. If nothing can grade it automatically, that’s not a detail, that’s Section 04 telling you not to loop this yet.

Write intent, not steps

A loop prompt is a different genre from a chat prompt. You specify the goal, the constraints, and the stopping behavior, and you let the loop determine the implementation on each pass. Cherny’s canonical example is one line:

# Intent + stopping behavior. No steps.
/loop babysit all my PRs. Auto-fix build issues, and when
comments come in, use a worktree agent to fix them.

For build loops, spec first: write the failing test before any code exists, and force a criterion check before the loop may mark a task done. The old TDD crowd will recognize this instantly, because it is TDD. The spec is the test, the evaluation is the test runner, the loop is red-green-refactor with the human moved up a level. Kent Beck wrote the book on this in 2002. The models finally caught up to it.

The strongest evidence that loops are the real shift and not a content wave: the three major agent platforms independently converged on the same primitives. When rivals agree on the shape of a thing, the thing is real.

Feature names as shipped or documented at time of writing, July 2026. All three move fast; verify before you architect around a cell.

What the creators actually run

Cherny published his own standing loop stack, and it’s wonderfully boring, which is exactly the point. The examples worth copying are never magical:

# Cherny's running loops, as published
$ /loop 5m /babysit        # auto-address review, rebase, shepherd PRs
$ /loop 30m /slack-feedback # put up PRs for Slack feedback
$ /loop /post-merge-sweeper # PRs for missed review comments
$ /loop 1h /pr-pruner       # close stale and unnecessary PRs

OpenAI runs the same class of thing internally: daily issue triage, CI failure summaries, commit briefings, hunting bugs somebody added last week. Notice the genre. Nobody’s loop stack is “build my startup while I sleep.” It’s janitorial. The compounding win of loops is that the janitorial layer of your work stops consuming your attention, permanently, and the attention goes to the work that was actually yours.

One question decides it, and it isn’t “how smart is the model.” It’s: who checks the work? If a machine can verify the output, the loop can run without you. If only you can verify it, the loop hasn’t removed the babysitting, it’s just rescheduled it.

The branch most guides won’t tell you about is the green one. A study on competitive programming tasks (arXiv 2605.08478) found that simply resampling, running k independent shots of a model and keeping what passes, consistently beat agentic scaffolds per dollar spent, across every difficulty tier they tested. If your failures vary between attempts, brute-force sampling against a verifier is embarrassingly effective and trivially parallel. Iterate when failures repeat and the error message carries information. Resample when they don’t. And route recurring chores straight past the tree to a schedule: PR babysitting, triage, nightly tests. The tree is for build work.

An agent bills like a compute job, not a seat. It reads big repos, spins sandboxes, runs tests, retries. The number that matters is cost per accepted change, and by that number 2026 has already produced its cautionary tale: Uber blew through its entire 2026 AI tools budget by April and capped engineers at roughly $1,500 a month per coding tool.

The experiment behind that chart deserves attention, stated precisely. A team at Journal spent $12,000 running all 731 tasks of SWE-Bench Pro through thirteen configurations of five Anthropic and OpenAI models, then asked what perfect task-to-model routing would have cost. With hindsight-perfect assignment, 93.6% accuracy for $814: better accuracy than Fable 5 xhigh alone (88.6%) at 38% of its $2,171 bill. That’s an upper bound, you don’t get hindsight in production. But here’s the part that needs no oracle: their most naive deployable policy, run everything on the cheapest model first and rerun on Fable 5 only on failure, hit 89.5% accuracy for $1,623. Read that again. A dumb two-model fallback beat the best single frontier model on accuracy and undercut it on cost by 25%. And the sentence that seeds our Section 06: the routed mix outperformed every individual model because it exploited each model’s particular strengths. One more thing, and it matters for what comes next: this experiment used closed models only. The 30x-cheaper open-weight tier wasn’t even in the mix. The cost floor they found is not the floor.

The raw material for all of this is the price gap. One published analysis puts DeepSeek-class agentic workloads near $0.094 per million tokens against $2.80+ for equivalent frontier workloads, a roughly 30x differential. Fable 5 lists at $10 per million input tokens and $50 per million output. Whether the gap is 30x or 15x on your workload, it is structural, and it is the fuel loops run on.

Now the honest math, because the gap alone doesn’t settle it

Loops multiply tokens. Agent workloads are brutally input-heavy: one published benchmark measured roughly 97% of loop tokens as input, because each step re-sends the growing context. Every auditor you add re-reads the diff and its context. So the real question is whether the price gap outruns the token multiplication. Worked example, illustrative and with assumptions stated, so you can attack it:

Illustrative. Assumes no prompt caching (caching improves the loop’s side of this math, since auditors share a prefix), a mid-size task, and open-weight blended rates in the $0.10-0.30 per M range. Run your own numbers before believing anyone’s, including ours.

One more cost line nobody puts in the spreadsheet: wall clock. A loop that takes forty minutes against a two-minute one-shot costs you calendar and attention even when the tokens are cheap. For scheduled overnight loops that cost rounds to zero. For interactive work it doesn’t, and “token rich” flat-rate plans versus “token poor” metered APIs change the calculus again. Know which one you are before copying anyone’s workflow, including Cherny’s. He does not meter his tokens. You probably do.

The routing data says a mix of models beats any single model. The Crucible Loop is what happens when you stop treating that as a cost trick and start weaponizing the disagreement itself.

Multiple metals in. One refined output. The build runs on cheap open-weight models routed through Flux Router (our LiteLLM-based smart router, Thompson sampling across 30+ models, so builder selection improves as results accumulate). The diff then goes to a parallel cross-audit: GLM 5.2, DeepSeek V4 Pro, Kimi 2.7 and MiniMax M3, each reviewing the same change independently. If the auditors agree it’s clean, it proceeds to the merge gate. If they split, and only if they split, a frontier verifier (Fable-class) arbitrates. The merge gate itself is non-negotiable: tests green, audits clean, and a human reads the diff. Yes, still. Section 07 covers why.

Why cross-audit instead of self-review

A model grading its own homework shares its own blind spots. The value of a second opinion is exactly proportional to how uncorrelated its failures are with the first, and four models from four different labs, four training lineages and four data recipes fail differently more often than four samples of one model. That’s the bet, stated as a bet. And it has a measurable health metric: the disagreement rate. If your auditors agree 99% of the time, you’re paying four bills for one opinion and the audit is theater. If they disagree constantly, your auditors are noise. The useful zone is in between, where a split is a signal worth escalating. We’re instrumenting exactly this through Flux Router’s telemetry, per task type, because nobody has published cross-model disagreement rates on real coding work and somebody should.

The economics of the shape

Recall the division of labor from Section 05: cheap does volume, expensive does judgment. The Crucible concentrates frontier spend at the single highest-value moment in the pipeline, arbitrating a genuine disagreement between models, and starves it everywhere else. In the worked example, the frontier line was $0.53 of an $0.85 task, and it only exists on the 30% of tasks where the auditors split. When the auditors agree, frontier cost is zero. The loop pays for itself out of the gap between $5.00 and $0.85, and quality holds because verification got stronger, not weaker, on the way down.

Every guide sells you the upside. Here’s the failure catalog, and we’ve brushed against most of these building our own stack, so consider this the section written in scar tissue rather than theory.

“Build the loop. But build it like someone who intends to stay the engineer, not just the person who presses go.”

Addy Osmani, “Loop Engineering” · June 2026

Every load-bearing claim in this manual, and where it comes from. If a claim isn’t here, treat it as our analysis and argue with us about it in the group.