Lesson 5 - Anti-Patterns: How Loops Go Wrong

Welcome to Anti-Patterns#

You’ve learned four patterns that make loops work. This lesson names the ones that make loops fail — the anti-patterns: loop shapes that look busy and productive but quietly go wrong. The good news, and the theme of the whole lesson, is that every anti-pattern has an antidote you already learned in an earlier module. An anti-pattern is simply what happens when a step gets skipped — so recognizing the shape points you straight at the fix. Then, in the module project, you’ll prove your pattern judgment by matching the right approach to four real scenarios.

By the end of this lesson, you will be able to:

• Recognize the four major anti-patterns
• Trace each one to the earlier-module skill that prevents it
• Diagnose why a loop that looks productive is actually failing
• Complete the project: match the right pattern to four scenarios

Let’s meet the anti-patterns.

The Four Anti-Patterns#

Infinite polish. The loop never ships — it keeps refining past the point where more effort adds any real value, chasing a “perfect” that isn’t worth reaching. It looks like diligence; it’s actually a loop with no finish line. Antidote: a concrete definition of done (Module 2) so there’s a real target, plus a budget (Module 6) so the loop stops even if the target is soft. Infinite polish is a missing stop condition wearing the costume of thoroughness.

Goal drift. The loop slowly optimizes for the wrong thing — each round makes a plausible change, but they accumulate away from what you actually wanted, until the loop is efficiently producing something off-brief. You met this in Module 1 and again in Module 6. Antidote: pin the goal with a clear definition of done (Module 2) and re-anchor it as you go (Module 4), so “closer to done” stays well-defined and the loop has a fixed finish line to move toward.

Verifier collusion. The reviewer just agrees with the doer — the check rubber-stamps the work because it shares the maker’s blind spots or simply flatters. The loop looks verified, but the “done” is false. This is the exact failure from Module 3’s most important lesson. Antidote: the two-hat technique (an independent reviewer) and anchoring the check to ground truth (Module 3), so the check can actually disagree with the work.

Over-automation. The loop exists at all when it shouldn’t — the task was really a one-shot answer, a fixed recipe, or a decision that needed a human, and wrapping it in an automated loop added cost, risk, and false confidence. Antidote: the “should this even be a loop?” test from Module 1 (stakes, checkability, variability), plus escalation (Module 6) for the parts a human should decide. Sometimes the best loop is no loop.

Anti-Patterns Are Skipped Steps#

Notice the pattern in the antidotes: every anti-pattern is what happens when you skip an earlier step, and its fix is that step. Infinite polish is a missing definition of done and budget. Goal drift is an unpinned goal. Verifier collusion is a check that isn’t independent. Over-automation is a skipped “should this be a loop?” question. This is why the course was ordered the way it was — each module prevents a specific way loops go wrong, and the anti-patterns are those failures showing up when the module’s lesson wasn’t applied.

That makes diagnosis wonderfully concrete. When a loop feels off, you don’t need to invent a fix — you identify which anti-pattern it is, and the antidote points straight back to the module that prevents it. “This loop won’t finish” → infinite polish → sharpen the done and set a budget. “It drifted off what I wanted” → goal drift → re-pin the goal. “It says done but it’s wrong” → verifier collusion → independent check. “Why is this even a loop?” → over-automation → maybe it shouldn’t be. Naming the shape is already half the fix.

A Pattern-Selection Cheat Sheet#

Before the project, here’s the whole module on one page — a quick map from a situation to the pattern that fits it, so you can pick instead of improvise:

Two rules of thumb sit under the table. First, default to draft-critique-revise and only reach for a heavier pattern when you can name why it won’t do (too big → plan; too varied → generate; too many independent parts → parallel). Second, combine freely — generate-and-test to find the idea, then draft-critique-revise to finish it; plan-then-execute whose steps are themselves parallel loops. The patterns are building blocks, not a menu you pick exactly one from.

The Module Project: Match the Pattern#

Here’s the project: for each scenario, name the pattern you’d use (or the anti-pattern to avoid) and justify it. Work through them before reading the answers.

1. Write a factual “our team” bio for the website. → Draft-critique-revise. One artifact, low variance, refine toward a standard. Watch for infinite polish — set a “done” (facts correct, under 80 words) so it ships.
2. Come up with a name for a new event. → Generate-and-test. High variance, first attempt is a coin flip — produce several diverse options and pick the best against a check, then optionally polish the winner. Refining the first name would trap you in it.
3. Produce a 20-page annual report with sections on finances, activities, and plans. → Plan-then-execute, likely with parallel loops (independent sections) and a handoff to an editing loop. Too big for one loop; plan first, check the plan, loop each section, then check the whole. Watch for verifier collusion — check the assembled report independently.
4. Decide whether to approve a large refund for an upset customer. → No loop — escalate. This is a high-stakes, judgment-and-values call that needs a human; automating it is over-automation. Use the AI to draft options or summarize the situation, but the decision escalates to you.

The skill this project builds is the whole point of the module: seeing a task and instantly knowing its shape — which pattern fits, and which anti-pattern to guard against. That recognition is what makes an experienced loop engineer fast and reliable, and you now have it.

Practice Exercises#

Exercise 1: Name the anti-pattern#

Which anti-pattern is each: (a) a loop that’s produced version 14 and still “isn’t quite right”; (b) an agent that “checked its own work and it’s perfect,” but it’s wrong; (c) automating a decision that’s really a one-time judgment call?

Exercise 2: Antidote from the module#

A loop keeps drifting away from the original brief over many rounds. Which anti-pattern, and which earlier-module skill fixes it?

Exercise 3: Pattern-match#

Pick the pattern: you need to fact-check eight independent claims in a document.

Summary#

Anti-patterns are loop shapes that look productive but go wrong, and there are four big ones — each the result of skipping an earlier-module step, and each fixed by that step. Infinite polish (never shipping) is a missing definition of done and budget (Modules 2, 6). Goal drift (optimizing the wrong thing) is an unpinned goal (Modules 2, 4). Verifier collusion (the reviewer agreeing with the doer — a false “done”) is a check that isn’t independent (Module 3), and it’s the most dangerous because it fails silently and confidently. Over-automation (looping what shouldn’t be a loop) is a skipped “should this be a loop?” test (Module 1). Because every anti-pattern maps to a fix you already know, diagnosis is concrete: name the shape, and the antidote points straight back to the module that prevents it. The module project — matching the right pattern (and the anti-pattern to avoid) to four scenarios — is that recognition made real, and it’s the core skill of pattern-based loop engineering.

Key Concepts#

• Infinite polish — a loop that never ships; fix with a concrete “done” and a budget.
• Goal drift — a loop optimizing for the wrong thing; fix by pinning and re-anchoring the goal.
• Verifier collusion — the reviewer rubber-stamping the doer; the most dangerous, fixed by independent checks.
• Over-automation — looping what should be one-shot, a recipe, or a human call; fix with the “should this loop?” test.

Why This Matters#

Anti-patterns are how loops fail in the real world, and recognizing them is what turns a frustrating “it’s not working and I don’t know why” into a precise diagnosis with a known fix. The deeper lesson is that this whole course is an anti-pattern-prevention system: each module exists to stop one specific way loops go wrong, so the anti-patterns are just those failures named. That’s why you can now look at almost any misbehaving loop and place it. You’ve completed the pattern vocabulary — refine one, decompose a big one, explore several, scale to many, and avoid the four failure shapes. The final module puts all of loop engineering to work in real life: trust, cost, privacy, reusable recipes, and handing loops to a team.

Continue Building Your Skills#

You can now name the four anti-patterns — infinite polish, goal drift, verifier collusion, over-automation — and trace each to the earlier-module skill that fixes it, and you’ve matched patterns to real scenarios. When a loop feels wrong, identify the shape; the antidote is already yours. You’ve finished the patterns module and the Going-Further track. Next, in the final module, loop engineering comes back to earth: using it responsibly in real work — trust and verification, cost and privacy, reusable recipes, scheduled loops, and giving loops to a team.