The Loop Operator's Manual

1. The Machine You're Operating

One picture. Every autonomous loop, everywhere, is this exact machine. If you understand this diagram, you understand everything else in this manual.

The loop. The judge is a separate brain from the worker: the worker never grades its own homework.

"Don't tell it what to do. Give it success criteria and watch it go." Andrej Karpathy, January 2026, after going from 80% manual coding to 80% agent coding in a single month.

Why this machine wins: Boris Cherny, who created Claude Code, ships hundreds of pull requests a month and says plainly, "I don't prompt Claude anymore. I have loops prompting Claude. My job is to write loops." Anthropic's own team ships 90% of Claude Code's production code this way. Jarred Sumner used 64 of these machines at once to port 535,496 lines of code in 11 days. Same machine, different sizes.

2. Hand Off Any Task, Step by Step

Four steps, every time. You can do this in two sentences of talking. The words in the orange boxes are literally what you say.

The anatomy of a perfect hand-off. Two sentences, four jobs done.

Say the outcome, not the activity

What does the world look like when this is done? Not "work on the site." What specifically exists at the end?

Say"Redesign the homepage hero section"

Say what's off-limits

One phrase that fences the work. This is what stops the agent from "improving" things you didn't ask about.

Say"Don't touch the checkout or the report pages"

Say "done when"

The single highest-impact habit in this manual. Give the finish line: a test that must pass, a screenshot that must match, a number that must be hit. Without it, "looks done" is the only stop signal, and that's how you get confident garbage.

Say"Done when it matches this screenshot on desktop and mobile, and it's live for my eyes"

Attach the evidence you already have

A screenshot, the error text, a link, or the name of something to copy. Pointing at a reference beats three paragraphs of describing. "Do it like the pricing page" is a complete instruction.

Say"screenshot attached, match this" or "do it like the pricing page"

The 2-strike rule (when it goes wrong)

If you've corrected the same mistake twice, stop correcting. The session is polluted. Say "fresh session" and restate the task including what you learned. And if a mistake should never happen again, say "make that a rule": it becomes permanent, and Cherny's data says this is the single habit that compounds ("write it to the rules file and Claude can run forever").

4. Build a Loop, Step by Step

When something earns loop status (you've asked for it twice, or it has a date, a checklist, or a "check again later"), it gets built like this. Six steps, in this exact order. Skipping a step is how loops become runaways.

The assembly line. Six stations, in order, every time. The framework refuses to run a loop missing stations 4, 5, or 6.

Write the finish line FIRST

Before any work: what does one successful pass produce, and how is it proven? Anthropic's team writes done-criteria to a file before execution so the goal can't drift mid-run.

Example"One pass = every new sales call graded against the rubric, report saved, evidence printed"

Pick the trigger

A time ("nightly at 2 AM"), an interval ("every 30 minutes"), or an event ("when a deploy finishes"). One trigger per loop.

Give the worker ONE unit of work per pass

Not "fix everything." One item, then stop. Small units mean every pass is reviewable and a bad pass costs you nothing.

Install a checker the worker can't touch

A test suite, a build command, a browser screenshot check. This is the load-bearing part. Sumner's 11-day port worked because 1,380,000 pre-existing test assertions were the ground truth and the agents were forbidden from modifying them. The OpenAI Codex team does the same: commit the failing tests first, then the agent implements until green WITHOUT touching the tests.

Add the independent judge

A separate fresh brain reads the finish line and the evidence, and defaults to FAIL. Never let the worker declare its own victory: an agent grading itself will delete the failing test and call it done. Claude Code's own goal mode uses a separate judge model for exactly this reason.

Cap it, then walk away

Max attempts, max minutes, max dollars, whichever hits first. The cap is the primary safety mechanism, not the completion signal. With all six pieces in place, the loop runs unattended and you only ever see results.

In our system, this is one command

The whole six-step contract is scaffolded by the loop framework (registry, runner, judge, and watchdog are already built). You say "loop that," the framework enforces steps 4, 5, and 6 mechanically, and a meta-loop watches every loop and flags any that miss a beat. You never have to trust discipline; the machinery refuses to run a loop without a checker and caps.

5. Run Your Day Like the Top Operators

The daily rhythm every documented top operator converged on. Your job stops being typing and becomes three short review windows.

Mitchell Hashimoto spends the last 30 minutes of every workday kicking off overnight agents. You review outcomes, not keystrokes.

Karpathy's autonomy slider: how long a leash per task

A loop EARNS a longer leash by passing its checker and judge repeatedly. Trust is granted by evidence, never by optimism.

"You can outsource your thinking, but you can't outsource your understanding." Andrej Karpathy, April 2026. You still own architecture, taste, and every merge. The agents own the typing.

6. Safety Rails

Five layers of defense stand between an autonomous loop and anything irreversible. Each ring has to be passed before the next one even gets asked.

The defense rings. A loop can pass rings 2 through 5 on its own. Ring 1 opens for exactly one key: you.

Never loop these. Ever.

Money (charges, refunds, transfers) · Production deploys · Outbound sends (email, SMS, posts) · Deletes · Judgment calls (pricing, strategy, people).

Loops PREPARE these and put them in your approval queue. A human presses the button. This matches every top operator: nobody credible, not Karpathy, not the Claude Code team, not Sumner, ships unreviewed autonomous actions on anything irreversible.

Rail	What it does
The checker	Rule-based pass/fail (tests, build, screenshot) runs on every pass, no exceptions.
The judge	A separate fresh brain confirms "done" against the written finish line. Defaults to FAIL.
The caps	Max attempts, max minutes, max spend. Hit any cap, the loop stops and reports.
The watchdog	A meta-loop checks every loop daily: missed schedule or failed judge = alert. Silence counts as failure.
The approval queue	Anything irreversible waits for a human. Decisions batch to your phone.

7. Troubleshooting: When a Loop Misbehaves

Three symptoms cover 90% of loop failures. Start at the top and follow the arrows.

The diagnostic flow. Symptom, cause, one fix. The table below is the full reference.

Symptom	Cause	Fix
Claims done, isn't done	No real finish line, or the worker graded itself	Tighten "done when" to things a machine can check. Confirm the judge is on.
Keeps failing the same way	The prompt is missing a guardrail	Add one numbered rule to the loop's prompt per failure. Tune it like a guitar; never rewrite it wholesale.
Rebuilds things that already exist	Fresh context can't see prior work	Add to the prompt: "search the codebase before assuming something is missing."
Runs forever, burns money	No caps	Caps are non-negotiable: attempts, minutes, dollars. The framework refuses capless loops.
Does extra work you didn't ask for	No constraints line	Add "only touching X" and "one unit per pass, stopping early is correct."
You corrected it twice, still wrong	Polluted context	Fresh session. Restate the brief with what you learned. Then "make that a rule."

The compounding law (the whole game in one line)

Every correction becomes a permanent rule, every repeated task becomes a loop, and every loop earns a longer leash by passing its judge. Do that for 90 days and the machine is unrecognizable. That's the entire method the top of the industry runs on.