Every Task Is Secretly a Recipe

The blob problem

"My work feels like one big blob — I couldn't explain the steps to anyone."

That sentence is more common than you'd think, and it's the exact wall between you and automation. In Module 1 you learned to SEE your repeated work. You have a log full of repeats. But try to hand one of those tasks to someone else — a new hire, a virtual assistant, an AI — and you hit the blob: *"I just... do it. I open some things, I look at some stuff, I write the thing, I send it."*

Here's the truth this lesson is built on: you cannot automate what you cannot explain. Not because machines are dumb, but because automation is fundamentally delegation — and delegation runs on instructions. The good news? The blob is an illusion. Every task you've done twenty times has a hidden structure your hands already know. Your fingers know the steps; your mouth just can't say them yet.

This lesson teaches you to extract that structure. The skill is called task decomposition, but we'll call it what it really is: writing the recipe.

Every task has edges

A recipe starts by finding the task's edges: where it truly begins and where it truly ends.

The beginning is the trigger — the event that makes the task exist. Not "Monday morning" vaguely, but precisely: *a customer email arrives asking for a quote. The meeting ends and notes are sitting in the doc. It's Friday at 3 PM and the report is due.* Every repeated task has a trigger, and naming it matters because the trigger is what will eventually start your automation without you.

The end is the done state — how the world looks when the task is finished. Again, precisely: *the quote email is sent and logged. The task list is posted in the team channel. The report PDF is in the shared folder.* "Done" is not a feeling; it's an observable result.

Everything between the trigger and the done state is your recipe. Most people discover their "blob" is really 5–9 small steps hiding in a trench coat.

Actions vs. decisions

Now the move that makes your recipe automation-ready — and it's the one most people skip. Go through your steps and sort every one into two piles:

Actions are mechanical: open the doc, copy the numbers, paste into the template, attach the file, hit send. No judgment required — if you wrote the instruction on a card, a stranger could do it exactly right.

Decisions are judgment calls: is this customer asking a standard question or something unusual? Does this draft sound right? Is this order worth a phone call instead of an email? A stranger with a card could NOT reliably make these calls — they need context, taste, or authority.

Why sort? Because in the next lesson you'll learn that actions and 'almost the same' drafting are what AI takes, and decisions are what you keep. A recipe with its decisions clearly marked is a recipe you can safely hand off — the machine gets the mechanical middle, and every decision point becomes a moment where the work pauses for you. This one habit is what separates safe automation from sloppy automation.

What each step needs to know

One more layer and your recipe is complete: for each step, name the information it needs. A step can't happen — for you, an assistant, or an AI — if its ingredients aren't on the counter.

Ask of every step: *what do I need to have in front of me to do this?* The answers are surprisingly consistent — they almost always fall into a few families:

From blob to recipe: two worked examples

Let's watch the whole move on two real tasks — the same people you met in Module 1.

Maria's Friday status email. For years Maria called this "just something I bang out." Written as a recipe, the blob dissolves:

Why this changes everything

Look at what just happened. Two "blobs" became recipes with numbered steps, marked decisions (★), named ingredients, and clear edges. Nothing was automated — and yet everything changed, because now these tasks are *explainable*. Maria could hand her recipe to a new assistant tomorrow. Tanya could tape hers next to the oven.

And here's where this module is heading: in the next lesson, you'll learn the universal pattern that turns a recipe like this into an AI workflow — which steps the machine takes, and where your ★ decisions slot in. The recipe you write today is the exact document you'll build from for the rest of this academy.

One warning before the exercise: don't polish. Your first recipe will be clumsy — steps out of order, a forgotten ingredient, a decision you didn't notice until you hit it. That's normal and fine. Recipes improve by being used, not by being perfected in advance.