🪜 The ladder, in 2 questions
Building a loop takes work. Before investing that effort, run the task through a decision ladder two steps. Only when the answer is YES on both is that it's worth building a loop. Otherwise, you spend engineering effort where a simple prompt would have been enough.
What to look at: are two steps, not a ramp. The task only "moves up" if it passes both. If it stumbles on either one, it falls back to the cheaper path — and that's a win, not a loss.
Read the diagram: the task only moves to the right while the answer is YES. A single NO sends it downward — to the simple prompt or to manual work. Building the loop is the rare case, saved for the end.
🧩 The ladder, in one sentence
"Only build a loop if the task repeats or has many unknown steps And AI can check "done" on its own." Remember this: the two questions in the next topics are exactly those two rungs, open.
❓ Question 1: repeat / many steps?
The first rung asks: the task repeats (you'd do again and again) or is there many unknown steps (you don't know the exact sequence in advance)? If it's a single predictable step, just prompt — a single prompt is faster and cheaper.
✓ Move up a level (repeat / many steps)
- •“Fix each failing test”—repeats once per test.
- •“Migrate 40 files to the new API”—many steps.
- •“Refactor until the lint passes”—you don’t know how many cycles it will take.
✗ Doesn't move up (one predictable step)
- •“Rewrite this paragraph in a more formal tone.”
- •"Translate this sentence into English."
- •"Summarize this email in 3 lines." → just prompt.
💡 The mental shortcut
Ask: “If I did this by hand, would I once or many times in a row?" If it's a one-time task, the loop is overhead. A loop exists to delegate the repetition — not to dress up a one-step task.
❓ Question 2: Does the AI check “done” by itself?
The second step is decisive: the AI can verify on its own that it's finished? Run the tests, count the words, make sure the file compiles — things the machine itself can read. If it there's no way to know that’s ready, do it yourself (or fix the objective first).
✓ The AI checks by itself
There’s a signal the machine can read:
- • Run the suite → “0 failing.”
- • Count words → “≤ 500.”
- • Build → “compiled without errors.”
✗ Only you know
There's no automatic signal:
- • “Is it elegant enough?” — taste.
- • “Is it ready to send to the client?” — judgment.
- • “Did it sound natural?” — depends on you reading it.
→ Do it yourself, or make “ready” objective first (Track 2, module 2.3).
🎯 Why this step is the heart
A loop only converges if it can answer "are we there yet?" on every turn. Without this check, it stops too early (delivering something broken) or never stops. It's the same truth from Trail 1: observe is what makes the loop work—here, it becomes the filter for "worth it or not."
📉 Most tasks do NOT need a loop
It's counterintuitive in a course about loops, but it needs to be said: most tasks don't need a loop. People who build good loops build few — and always through the verification, not for the elegant architecture.
🗣️ What practice shows
Nate Herk: "most tasks don’t need a loop." When it does loop, it’s because of the verification — not because a loop is more sophisticated.
And you don’t need a huge architecture: often all it takes is one terminal session + one good prompt. The loop is a decision, not a trophy.
What to look at: the funnel starts wide and ends narrow. The loop is the narrow exit at the bottom—the destination for a minority of tasks, not the default.
Loops cost money
More tokens, more latency, more ways things can go wrong. Pay that cost only when it pays off.
The reason is verification
It only becomes a loop when you need many verified turns before it’s "done" — that’s the real gain.
Start small
A terminal + a good prompt go a long way. Big architecture is the exception, not the starting point.
🎯 Repetitive, reviewable, high value
The ladder filters by YES/YES, but practice adds nuance: loops work best for tasks that are repetitive, reviewable, and high-value — not for everything. A Firecrawl summarize it this way: a good candidate combines all three; leave out anything that doesn’t.
✓ Good loop candidate
✔ Repetitive — the same operation across many items.
✔ Reviewable — you can check each result.
✔ High value — getting it right is worth the cost of the iterations.
✗ Poor loop candidate
✘ Unique — happens only once.
✘ Not reviewable — only you know whether it turned out well.
✘ Low value — the result doesn’t justify the effort.
| Task | Repetitive | Reviewable | Value | Loop? |
|---|---|---|---|---|
| Fix 12 tests | ✓ | ✓ | high | YES |
| Migrate 40 files | ✓ | ✓ | high | YES |
| Rewrite 1 email | ✗ | — | low | NO |
| “Make it look good” | — | ✗ | ? | NO |
🧪 Applying the ladder
To wrap up: let’s run three real tasks through the ladder and see the verdict. Notice that the result isn’t always “loop”—and that depends on being able to check whether it’s 'done' more than anything else.
Test fix
Q1: repeats (through testing) ✓. Q2: the AI runs the suite and reads "0 failing" ✓. YES/YES → build a loop.
Rewrite 1 email
Q1: one predictable step, doesn’t repeat ✗. It already fell at the first hurdle. Just prompt (one-shot).
Broad exploratory research
Q1: many steps ✓. Q2: depends — can you check whether it’s “done”? If you define a criterion (“covered N confirmed sources”), it qualifies; if it’s “until it seems sufficient,” it doesn’t. Fix the objective first.
You need to "rewrite a single paragraph in a more formal tone." What does the ladder say?
🧾 Module Summary
Next:
2.2 — The 3 types of loop (Solo, Maker→Checker, Manager→Helpers)