Loop Engineering Explained: Ralph Wiggum Technique vs Claude Code's Native /loop

Q: Does Claude Code have a native loop command?

Yes. Claude Code's `/loop` command landed in March 2026 for polling-style tasks — checking a deploy, watching a log, babysitting a PR on a timer. It is session-scoped: it dies when you close the session, only fires while the session is idle, and an unattended loop auto-expires after seven days. That makes it a different, lighter-weight tool than a persistent Ralph-style loop, which is designed to survive across sessions by living entirely in files on disk.

TL;DR

Loop engineering is a June 2026 term (coined by Peter Steinberger, named by Addy Osmani) for designing a system that prompts an AI coding agent repeatedly, checks its work, and repeats — instead of writing one prompt and reading one reply.
It is not the same thing as the "Ralph Wiggum technique" — Ralph is Geoffrey Huntley's specific 2025 implementation (a persistent shell loop with file-based memory); loop engineering is the broader 2026 name for the practice, and now includes Claude Code's own built-in tooling.
Claude Code ships a native /loop command (landed March 2026) that is session-scoped and dies when you close the session — a different, lighter-weight tool than a Ralph-style persistent loop.
Run this 5-question checklist before building a loop: if you can't name one deterministic "done" check, you don't need loop engineering yet.
I run parallel agent loops daily across 5 production sites; the honest failure modes and cost math are linked below.

Jump to: What Is Loop Engineering? · Where the Term Came From · Loop Engineering vs /loop vs Prompt Engineering · Is It Right for You? · FAQ

What Is Loop Engineering?

Loop engineering is the practice of designing a system — not a single prompt — that triggers a coding agent, lets it act, checks the result against a fixed condition, and repeats until that condition holds. Where prompt engineering optimizes what you say in one turn, loop engineering decides what happens after the agent replies: does it try again, does it escalate to you, or is it actually finished.

The term itself is new. It surfaced on June 8, 2026, when Peter Steinberger (creator of OpenClaw, now at OpenAI) posted on X: "Here's your monthly reminder that you shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents." That post hit roughly 6.5 million views. Four days earlier, Boris Cherny — who leads Claude Code at Anthropic — had already described the same shift in a CNBC interview: he said he no longer writes prompts himself, Claude writes the prompt, and he's "talking to that new Claude that is kind of coordinating." Writer Addy Osmani then published an essay titled "Loop Engineering" that gave the pattern its name and a five-part architecture, and the framing spread through developer newsletters over the following week.

None of this is really new mechanics — it's a new label on a pattern that had already been running inside Claude Code's own team, and one that a smaller community of agent builders had been calling the "Ralph Wiggum technique" since mid-2025.

Where the Pattern Came From: the Ralph Wiggum Technique

Before "loop engineering" had a name, Geoffrey Huntley was already running it under a different one. In mid-2025 he described feeding the same prompt file to a coding agent inside an infinite shell loop — the agent reads the file, edits the codebase on disk, and the filesystem and git history become its memory instead of the conversation window. Failures from one pass get piped back in as context for the next, which Huntley calls a "contextual pressure cooker": the agent is forced to confront its own previous mess until it finds a solution that survives the loop's own check.

He named it after the Simpsons character — a running joke about how simple and repetitive the mechanism is, despite how well it works on bounded, verifiable tasks. It went viral in late 2025, and by December 2025 Anthropic had shipped an official ralph-wiggum plugin for Claude Code, folding the community pattern into the product itself.

That is the important distinction to keep straight: Ralph is a specific implementation (persistent shell loop, file-based memory, no hard session limit besides your own patience and budget). Loop engineering is the broader 2026 name for the category of technique Ralph belongs to — which now also includes lighter-weight tools like Claude Code's native scheduling command.

Loop Engineering vs Claude Code's Native /loop vs Prompt Engineering

These three get conflated constantly because they all involve "the agent doing something more than once." They are not interchangeable.

Dimension	Prompt Engineering	Claude Code `/loop` (native)	Ralph-Style Persistent Loop
Unit of work	One crafted prompt, one reply	A prompt re-fired on a timer inside a live session	A prompt file re-fed to the agent every pass, outside any single session
Where memory lives	The conversation	The current session's context	The filesystem and git history
Lifecycle	Ends when you stop	Session-scoped — dies when the session closes, and unattended loops auto-expire after 7 days	Runs until the acceptance check passes or you kill the shell loop yourself
Who judges "done"	You, reading the reply	You, or a separate small model (that's what `/goal` does instead)	A deterministic check baked into the loop — a test suite exit code, a lint count, a build
Good fit	One-off questions, single edits	Polling jobs: "check the deploy every 5 minutes," babysit a PR	Bounded, verifiable jobs: framework migrations, a bugfix with a repro, working through a backlog
What breaks it	Vague asks, needing 10 follow-ups	Forgetting it only fires when the session is idle, or expects to survive a closed laptop	No budget cap — the loop keeps "trying" and burns API cost with no ceiling

A detail worth being precise about, since it trips people up: Claude Code's /loop is not the always-on Ralph pattern squeezed into a slash command. It landed in March 2026 for polling-style jobs — checking a deploy, watching a log, babysitting a PR — and it is explicitly session-scoped. A session can hold up to 50 scheduled loop tasks at once, each with a short ID, but every one of them dies the moment you close that session, and an idle, forgotten loop expires on its own after seven days. If you drop the interval, /loop becomes self-paced: Claude checks its own stop condition and decides whether to go again. That self-pacing is the closest native overlap with Ralph — but a Ralph loop is designed to survive across sessions by living in the filesystem, and Claude Code's /loop is designed not to.

Is Loop Engineering Right for Your Project? A 5-Question Check

Loop engineering has a real failure mode: building loop infrastructure for a task that a single good prompt would have handled in thirty seconds. Before reaching for a persistent loop, answer these five questions honestly.

Can you name one deterministic pass/fail check for "done"? A test suite that exits 0, a lint error count, a load test against a p95 threshold, a word count on a document. If your only check is "read the output and decide if it feels right," a loop has nothing objective to run against.
Is the job actually bounded? Will it plausibly finish in 5, 20, or 50 passes — not run indefinitely because the goal keeps moving?
Does progress survive outside the conversation? Files on disk, commits in git — something a fresh agent invocation can pick up mid-task without you re-explaining everything.
Are you willing to set a hard budget cap and walk away? An iteration limit or a dollar limit, with an escalation rule for when nothing has improved after N consecutive passes.
Is this coding-shaped work? A migration, a bugfix with a reproducible failure, clearing a backlog of similar items — as opposed to an open-ended creative or judgment call that needs a human read on "good enough."

Score it: 4-5 yes → you have a real loop-engineering candidate; start with a persistent, Ralph-style loop capped at a small iteration budget so a runaway pass can't burn your whole day's API spend. 2-3 yes → try Claude Code's native /loop first — it's session-scoped and lower-stakes, and you can graduate to persistent infrastructure once you've proven the acceptance check actually works. 0-1 yes → skip loop engineering for now. A well-written single prompt — classic prompt engineering — will get there faster and with less to maintain.

We Already Run Loops Like This in Production

This isn't theoretical for us. I run this site along with four others solo, and Claude Code subagents running in parallel — dispatched from one commander prompt, each with its own isolated context and its own acceptance check — are how I generate SEO tool pages and content across all of them without spending my whole day at the keyboard. I've also broken a database with a relative file path that a subagent silently resolved against the wrong working directory, and I've had a subagent report success on an SEO page that Google then couldn't see. The honest recipes and pitfalls from three months of that are in Claude Code Subagents: 6 Pitfalls From 3 Months of Real Parallel Workflows — most of what applies to parallel subagents (absolute paths, explicit "do NOT deploy" instructions, never parallelizing steps with output dependencies) applies just as directly to a single agent looping on its own.

Build Your Own Loop Prompt

If your 5-question score came back in loop-engineering territory, the next step is writing the actual prompt — not just deciding you want one. The AI Agent Loop Prompt Builder walks through the trigger, the acceptance check, the budget cap, and the escalation condition as separate slots, scores the result for safety on a 0-100 scale, and exports setup notes for Claude Code, Cursor, and Codex specifically.

Two things worth checking before you let a loop run unattended for hours: what it will actually cost, and whether you'll notice if it goes sideways. The LLM API Cost Calculator and Anthropic API Pricing Calculator will price out a long-running loop against your expected iteration count before you start it, and AI Agent Observability Platforms covers the tracing setups people actually use to watch a loop from outside the session instead of babysitting the terminal.

FAQ

What is loop engineering?

Loop engineering is designing a system — a trigger, an acceptance check, a budget, and an escalation rule — that runs an AI coding agent repeatedly until a fixed condition is met, rather than writing a single prompt and reading a single reply. The term was coined by Peter Steinberger and named in an essay by Addy Osmani in June 2026, building on a practice that was already running inside Anthropic's own Claude Code team.

Is loop engineering the same as the Ralph Wiggum technique?

No, though they're closely related. The Ralph Wiggum technique is Geoffrey Huntley's specific 2025 implementation — a persistent shell loop that re-feeds the same prompt file to an agent, using the filesystem and git history as memory instead of the conversation window. Loop engineering is the broader 2026 name for the category of technique Ralph belongs to, and it now also covers lighter-weight tools like Claude Code's native /loop command, which works differently from Ralph under the hood.

Does Claude Code have a native loop command?

Yes. Claude Code's /loop command landed in March 2026 for polling-style tasks — checking a deploy, watching a log, babysitting a PR on a timer. It is session-scoped: it dies when you close the session, only fires while the session is idle, and an unattended loop auto-expires after seven days. That makes it a different, lighter-weight tool than a persistent Ralph-style loop, which is designed to survive across sessions by living entirely in files on disk.

Do I need loop engineering for a small project?

Usually not. If you can't name one deterministic pass/fail check for "done," or the task is a one-off edit rather than a bounded, repeatable job, a normal single prompt will get you there faster with nothing extra to maintain. Loop engineering earns its cost on framework migrations, bugfixes with a reproducible failure, and backlogs of similar tasks — not on open-ended or judgment-call work.

How much does running an agent loop cost, and how do I stop it running forever?

Cost scales with iteration count and the model you loop on, so price it out before you start — a long Opus-class loop can run up noticeably more than the same job on a cheaper model. Set two hard limits going in: a budget cap (an iteration count or a dollar ceiling, whichever comes first) and an escalation rule that hands control back to you when no progress has been made for several consecutive passes. Without both, a loop can keep "trying" and exhaust your compute budget before you notice.