Lesson 3 - Loop Recipes

Welcome to Loop Recipes#

You’ve spent a whole course learning to build loops well — a good goal, an honest check, the right pattern, safe stopping. That’s real effort, and it would be a waste to spend it fresh every single time. This lesson is about capturing a loop that works, so you never rebuild it from scratch: turning it into a recipe — a reusable asset that gathers everything the loop needs into one place. Get a loop right once, write it down as a recipe, and it becomes a standing capability you can rerun in minutes and hand to someone else intact.

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

• Explain what a loop recipe is and why it’s worth capturing
• List the parts a good recipe records
• Turn one of your working loops into a recipe
• See how a recipe unifies everything you’ve built

Let’s define the recipe.

A Recipe Is the Whole Loop, Written Down#

A loop recipe is a short, reusable record of a loop that works — everything needed to run it again well, in one place. It’s the natural endpoint of a theme you’ve seen all course: the brief library from Module 2, the Project from Module 4, the CLAUDE.md from Module 5 were all versions of “write the reusable parts down once.” A recipe generalizes that to the entire loop, not just the brief.

Look at the card and notice something satisfying: a recipe is the whole course on one page. The goal is Module 2. The definition of done is Module 3. The pattern is Module 7. The stop conditions are Module 6. Where to run it is Modules 4 and 5. And what to always check yourself is Module 8. A complete recipe is proof that you’ve assembled every skill into one working loop — which is exactly what the capstone will ask you to do.

What a Good Recipe Records#

You don’t need a special format — a note, a doc, a card — but a good recipe captures these parts, because each is something you’d otherwise have to reconstruct:

• The goal / brief — what outcome the loop produces (Module 2).
• The definition of done — the check the loop runs against (Module 3). This is the part most worth saving, because a good check is the hardest thing to get right and the easiest to forget.
• The pattern — which loop shape it uses: draft-critique-revise, generate-and-test, and so on (Module 7).
• The stop conditions — when it finishes and when it gives up (Module 6).
• Where and how to run it — the tool and setup: which Project, which agent, any CLAUDE.md (Modules 4–5).
• What to always check yourself — the trust notes from Lesson 1: the specific things a human confirms before relying on the output.

The discipline is simply to write these down when a loop works, rather than in the moment of needing it again. Right after a loop produces a great result is when you understand it best; capturing it then costs a couple of minutes and saves you rebuilding it later — often after you’ve forgotten the very details (the exact check, the stop rule) that made it work.

Recipes Turn One-Off Wins Into Capability#

Here’s the deeper payoff. Without recipes, every good loop is a one-off — you solved the problem this time, and next time you start over, maybe getting it right, maybe not. With recipes, a good loop becomes a standing capability: the newsletter recipe means “produce the newsletter” is now a reliable, repeatable thing you own, not a task you re-figure-out weekly. A handful of recipes for the loops you run often turns “I can use AI well when I concentrate” into “I have a set of dependable tools that produce good work on demand.”

This is also what makes loops shareable, which is the next two lessons. A recipe is self-contained enough to hand to a schedule (Lesson 4) or a teammate (Lesson 5) — because it records not just what to do but the check, the stop rules, and what to watch. A loop in your head helps only you, only when you’re paying attention. A loop written as a recipe helps every future run, every schedule, and every person you share it with.

A Harborlight Example#

After a few weeks, the owner has the newsletter loop dialed in — the right brief, a check that reliably catches invented books and length problems, a draft-critique-revise with fresh-eyes review. Instead of leaving that knowledge in their head, they spend three minutes writing the recipe: the card in the figure. Goal, definition of done, pattern, stop conditions, the Project it lives in, and the note to always check the facts and event date themselves.

The payoff is immediate and compounding. The next week, “write the newsletter” is grabbing the recipe and running it, not reconstructing what made it work. When they go on holiday, they hand the recipe to a colleague and the newsletter still goes out to the same standard, because the check and stop rules travel with it. And when they build the next loop — the monthly events roundup — they start from the newsletter recipe as a template, changing the goal and check but keeping the shape. Three minutes of writing turned a good loop into an asset they, and their shop, will use for a year.

Practice Exercises#

Exercise 1: What’s missing?#

A colleague’s recipe records the goal and the tool, but nothing else. Which parts are missing, and which of those is the most costly omission?

Exercise 2: When to write it#

When is the best moment to write a loop’s recipe, and why?

Exercise 3: One-off to capability#

Explain the difference, in practice, between running a good loop once and having it as a recipe.

Summary#

A loop recipe is a short, reusable record of a loop that works — the whole loop written down in one place — and it’s the natural endpoint of the “write the reusable parts down once” theme running through the brief library (Module 2), Projects (Module 4), and CLAUDE.md (Module 5). A good recipe records the goal, the definition of done (the most valuable part, since a good check is hardest to get right and easiest to forget), the pattern, the stop conditions, where and how to run it, and what to always check yourself — which means a complete recipe is essentially the whole course assembled on one page. Write the recipe at the moment of success, when the details are fresh, rather than when you next need it. The payoff is that recipes turn one-off wins into standing capability — a task becomes a dependable, repeatable asset you own — and they make loops shareable, self-contained enough to hand to a schedule or a teammate with the check and guardrails intact.

Key Concepts#

• Loop recipe — a reusable record of a working loop: goal, check, pattern, stop rules, setup, and trust notes.
• The check is the key part — the definition of done is the hardest-won and most worth saving.
• Capture at success — write the recipe when the loop just worked and the details are fresh.
• One-off to capability — recipes turn a good loop into a standing, repeatable, shareable asset.

Why This Matters#

Recipes are what make loop engineering compound: without them, every good loop is a fresh effort, but with them, your skill accumulates into a growing set of dependable tools that produce good work on demand. It’s the difference between being someone who can use AI well and someone who has a reliable AI-powered workflow. Recipes are also the bridge to scale — a captured loop is ready to run on a schedule or in someone else’s hands, which is exactly where the module goes next. Next, you’ll put a recurring loop on a schedule, and learn the extra guardrails a loop needs when it runs without you watching.

Continue Building Your Skills#

You can now capture a working loop as a recipe — goal, check, pattern, stop rules, setup, and trust notes in one place — so a loop you got right becomes a standing asset instead of a one-off. Write the recipe the moment a loop works, while it’s fresh. Next, you’ll take a recipe and put it on a schedule, running the loop automatically — and add the guardrails that keep a recurring, unwatched loop safe.