Lesson 1 - Draft, Critique, Revise

Welcome to Draft, Critique, Revise#

You can now run a loop and stop it safely. This module adds judgment: instead of improvising a loop every time, you’ll recognize the situation and reach for a proven pattern. Named patterns are how experienced people move fast — you see a task and think “that’s a generate-and-test” the way a cook sees ingredients and thinks “stir-fry.” We start with the most fundamental one, the loop you’ve actually been running since Module 3: draft, critique, revise. Naming it turns something you’ve been doing by feel into a tool you can reach for deliberately.

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

• Describe the draft-critique-revise pattern and its three moves
• Explain why the critique step is really the check
• Recognize the tasks this pattern fits best
• Know its limits — where a different pattern serves better

Let’s name the pattern.

The Pattern You Already Know#

Draft-critique-revise is exactly what it sounds like, and you’ve done it dozens of times in this course. Draft a first attempt. Critique it — find what’s wrong against your criteria. Revise to fix precisely those flaws. Then critique again, and repeat until the critique turns up nothing that matters. It’s the plain loop from Module 1, with the three moves named.

The reason to name it is that it makes the roles explicit. There’s a doer (draft and revise) and a critic (critique). Seeing those two roles is what connects this pattern to everything you learned in Module 3: the critique step is the check. A draft-critique-revise loop with a weak critique is just a draft-and-hope loop with extra steps. Everything that made a check good — named criteria, demanded evidence, fresh eyes — is exactly what makes the critique good. This pattern is the check-building skills of Module 3, arranged into a repeatable shape.

Naming the pattern also clarifies when to stop cycling — the stop conditions from Module 6, applied here. You stop when the critique turns up nothing that matters (the success exit), or when you hit a round limit even if it’s not perfect (the safety exit). Both are important: without the success condition the loop wouldn’t know it’s done, and without the round limit a picky critique could keep the loop revising forever — the infinite-polish anti-pattern you’ll meet at the end of the module. A healthy draft-critique-revise usually converges in two or three cycles; if yours is on round eight and the critique keeps finding small new things, that’s the signal the critique lacks a clear “good enough” bar, not that the work needs more polishing.

Why It’s the Default#

Draft-critique-revise is the workhorse — the pattern you reach for unless you have a specific reason not to — for three reasons.

It needs no special setup. It runs in a plain chat window, by hand, with no tools, no code, and no orchestration. That makes it the most accessible pattern and the right starting point for almost any refinement task.

It’s cheap and legible. One attempt, improved step by step, is easy to follow — you can see each round’s change and why. Compared to patterns that run many attempts or many agents, it’s the simplest to reason about and the least likely to surprise you.

And it fits most single-artifact refinement. Writing a newsletter, tightening a paragraph, cleaning up a document, polishing an email — anything where you’re improving one thing toward a standard — is a natural draft-critique-revise. If your task is “make this one thing good,” this is almost always the pattern. Because it’s the default, the other three patterns in this module are best understood as answers to specific ways draft-critique-revise doesn’t fit — a useful way to hold the whole set in mind: you reach for a different pattern only when you can name why this one won’t do.

Where It Falls Down#

No pattern fits everything, and knowing where draft-critique-revise struggles is what points you to the rest of the module.

It’s weak when the first draft is a coin flip. For tasks with high variance — brainstorming a tagline, a creative concept, anything where attempts differ wildly in quality — improving one draft can trap you in a mediocre starting point. There, generating several independent attempts and picking the best (generate-and-test, Lesson 3) beats polishing one.

It strains when the task is too big for one artifact. Refining a whole thirty-page report as a single draft-critique-revise loop is unwieldy; the critique can’t hold it all, and revisions in one place break another. A big task wants to be planned and broken into pieces first (plan-then-execute, Lesson 2), each piece its own small draft-critique-revise.

And it can spin when the critique is weak — the oscillation and infinite-polish failures from Module 6, which are really critique failures. Draft-critique-revise is only as good as its critique, so a soft critique produces a loop that revises forever without converging.

A Harborlight Example#

The owner writes the weekly newsletter — a textbook draft-critique-revise. Draft: ask Claude for a first version against the brief. Critique: in a fresh chat (fresh eyes), paste the draft and the definition of done and ask for a per-criterion verdict with evidence — 312 words (too long), one invented book, tone fine. Revise: back to the doer with exactly those two fixes. Critique again: the fresh reviewer confirms all criteria pass. Done in two cycles. It ran entirely in a browser, needed no tools, and was easy to follow round by round — the pattern doing exactly what it’s best at: refining one artifact toward a standard.

Later that day the owner needs three completely different tagline concepts for a poster. They start a draft-critique-revise on the first tagline and it feels wrong — polishing one so-so idea rather than exploring. That’s the tell that a different pattern fits, which is exactly where the next lessons go.

Practice Exercises#

Exercise 1: Name the moves#

In “I asked for a bio, it flagged that the bio missed my current role, I had it add that, and it confirmed the bio was complete,” label the draft, critique, and revise steps.

Exercise 2: Fit or not?#

For each, is draft-critique-revise a good fit: (a) polishing a cover letter, (b) generating five different logo concepts, (c) tidying one product description?

Exercise 3: Strengthen the critique#

A draft-critique-revise loop keeps revising forever without finishing. Where’s the problem, and what’s the fix?

Summary#

Draft-critique-revise is the foundational loop pattern and the one you’ve run since Module 3: draft an attempt, critique it against your criteria, revise exactly the flaws found, and repeat until the critique turns up nothing that matters. Naming it makes the roles explicit — a doer and a critic — and reveals that the critique step is the check, so everything from Module 3 (named criteria, demanded evidence, fresh eyes) is what makes it work; it’s strongest when the critique runs with two-hat separation rather than self-flattery. It’s the default pattern because it needs no setup, is cheap and legible, and fits most single-artifact refinement — “make this one thing good.” Its limits point to the rest of the module: it’s weak when the first draft is a coin flip (use generate-and-test), it strains when the task is too big for one artifact (use plan-then-execute), and it spins when the critique is weak (an infinite-polish failure).

Key Concepts#

• Draft-critique-revise — the everyday loop pattern: produce, find flaws, fix, repeat.
• Doer and critic — the two roles the pattern makes explicit; the critic runs the check.
• The critique is the check — Module 3’s check-building skills applied as a repeatable shape.
• Its limits — coin-flip first drafts, oversized tasks, and weak critiques point to other patterns.

Why This Matters#

Naming the default pattern turns a thing you did by feel into one you reach for on purpose — and, more importantly, it locates the check at the heart of your everyday loop, so improving your critiques improves nearly everything you do. Recognizing where draft-critique-revise doesn’t fit is just as valuable: it’s the cue to reach for a better-suited pattern instead of forcing the wrong one. Next, you’ll learn the pattern for tasks too big to draft in one piece — plan then execute, which breaks a large job into a plan first and runs a small loop for each step.

Continue Building Your Skills#

You can now name and reach for the workhorse pattern — draft, critique, revise — and you know its heart is the critique, best run with fresh eyes. Use it as your default for any single-artifact refinement, and treat its poor fits as signals to switch patterns. Next, you’ll handle the tasks too big for one draft: plan-then-execute, where you break a large job into a plan and run a focused loop on each piece.