从提示到自治：设计 AI 工作循环的五个阶段

The person who created Claude Code says he doesn't really prompt it anymore. Loops prompt it. His job is to design the loops.

That one sentence is the whole shift happening in 2026. For two years the move was simple: write a good prompt, feed context, read what comes back, type the next thing. You held the agent the entire time, one turn at a time. That era is closing.

The new skill is building a small system that finds the work, hands it out, checks it, and decides what's next, while you watch instead of type. It's called loop design, and it isn't one skill, it's a ladder. Here are the 5 levels, from where almost everyone starts to where the best builders operate. Find your rung.

You write a prompt, read the answer, write the next prompt.

This is where everyone starts and where most people stay. You type a request, the agent answers, you read it, you type the next request. The agent is a tool you hold in your hand the whole time. Every single turn requires you.

Nothing wrong with it for quick tasks. But it has a hard ceiling: your throughput is capped by how fast you can type and read. You are the loop. And a human running the loop is slow, gets tired, and can only do one thing at a time.

You're in this level if "using AI" means a chat window where you send messages and read replies, one at a time.

You repeat the same cycle by hand: do, check, correct, repeat.

At level 2 you've noticed a pattern: most real work is a cycle, not a single answer. Do the thing, check it, fix what's wrong, repeat until it's right. You start running this cycle deliberately: "now run the tests," "now fix that failure," "now check again."

This is the first real loop, but you're still the engine driving it. You're manually pushing the agent through each stage. It's better than level 1 because you're thinking in cycles, but you're still spending your attention on every lap.

You're here if you find yourself typing "run it again," "now check," and "fix that" over and over in a session.

You define "done," and a check decides when the loop stops.

Level 3 is the first real jump in skill. Instead of you eyeballing whether each lap worked, you write down a success condition and let a check enforce it. The loop now has a stopping criterion that isn't your opinion: tests pass, lint is clean, the output matches a rubric.

This is the level where loop design becomes a real discipline. The key insight: the agent that did the work is a bad judge of whether the work is done, it tends to over-report success. So the check has to be separate from the doer.

A VERIFIED LOOP HAS A SEPARATE JUDGE
# the doer does. a separate check decides "done".
LOOP until: all tests in test/ pass AND lint is clean

# the model that wrote the code does NOT get to grade itself
# a separate check (tests, a faster grader model) decides

You're here if you can state "done" as a condition a machine could check, not a feeling you have to confirm.

You set a goal, the loop runs across turns on its own until it's met.

At level 4 the loop runs itself. You set a goal and a stopping condition, and the system loops across many turns without you driving each one: it reads the failure, traces the cause, makes the change, re-checks, and repeats until the condition is true. You check in when you want, but you don't have to hover.

In Claude Code this is now a native primitive. The /goal command runs a loop across turns until a condition you wrote is true, and crucially it uses a separate, faster model to grade whether the goal is met after each turn, instead of trusting the doer's word.

A SELF-RUNNING GOAL LOOP
/goal All tests in the suite pass with no skips or warnings
/loop every 2m until: tests pass

# Claude reads failing output, traces the cause, edits,
# re-runs, and repeats, on its own, until the goal is met
# a separate fast model checks the condition each cycle

The level-4 discipline:A self-running loop needs guardrails or it spins. Cap the iterations (a max-turns limit), front-load context so it doesn't wander, and snapshot state before each turn so a bad lap can roll back. Autonomy without limits is just a faster way to make a mess.

Loops that start themselves, run in parallel, and improve over time.

Level 5 is where loop design becomes systems design. The loops don't wait for you to start them, they trigger on their own (a schedule, an event), run in parallel, and feed their lessons back so the system gets better over time. You're no longer operating an agent. You're running a small organization of them.

Three things define this level:

• Self-starting: routines and automations kick loops off on a timer or an event, so work happens without you pressing go
• Parallel: many loops run at once in isolated worktrees, a lead integrating their results, instead of one loop at a time
• Self-improving: when the system makes a mistake, the lesson gets written back into CLAUDE.md or a skill, so the correction persists into every future run instead of being lost

What level 5 actually feels like:You describe outcomes, not steps. The system finds the work, dispatches it, checks it, records what's done, and decides what's next. Your job shifts entirely from doing the work to designing the system that does it.

You don't jump from 1 to 5. You climb one rung at a time, and each rung is a specific, learnable move:

• 1 → 2: stop asking for single answers. Notice the cycle in your work and run it on purpose
• 2 → 3: write "done" as a condition a machine could check, and let the check decide, not you
• 3 → 4: hand the running of the loop to a goal command, and add guardrails so it can't spin
• 4 → 5: let loops start themselves, run in parallel, and write their lessons back so they improve

The honest takeaway:Most people are stuck at level 1 or 2 not because the higher levels are hard, but because nobody told them the ladder exists. The skill of 2026 isn't a better prompt. It's knowing that "design the loop" is a thing you can do, and climbing one rung at a time until the work runs without you.