You’ve been told to break it into smaller steps.

You’ve tried. And what you produced was a list of things like sort out the structure, look into the pricing, draft the opening section — which is a smaller list than “write the book,” and you still can’t start.

That’s not a failure of effort. The standard advice stops one level above the level where anything becomes executable, and it gives you no test for knowing whether you’ve gone far enough.

Here’s the method with the test attached, and — more usefully — what to do at the three points where decomposition reliably stalls.

The Method

Decomposition converts an outcome into an executable action by resolving it through successive levels. A goal names an outcome and is not actionable. A milestone marks a finite waypoint, converting an unbounded objective into a bounded one. A module is a coherent chunk of work, which resembles a task but typically still contains unresolved decisions. A moment is a single action that can be started within sixty seconds and completed without any further decision, and is the only level at which execution occurs. Most attempts at decomposition terminate at the module level, because modules superficially resemble tasks, which is why the instruction to break work into smaller steps frequently fails to produce action. Decomposition also stalls at three recurring points: an unknown method, an unresolved decision, and a dependency on another person. Each converts into a task by a specific substitution rather than requiring the original obstacle to be removed.

Four levels, one test, three stalls.

The Four Levels, Briefly

Goal. “Write a book.” Names an outcome. Not actionable and not supposed to be — its job is direction.

Milestone. “Finish a first draft.” Still not actionable, but it converts an infinite object into a finite one, which reduces the load of holding it.

Module. “Draft chapter three.” Looks like a task. Isn’t. It contains unresolved decisions — what goes in it, how it opens, whether the structure holds — and you’ll hit one of those and stall.

Moment. “Open the chapter three file and write the first sentence, however bad.” Nothing left to decide. You could be doing it in fifteen seconds.

The difference between module and moment isn’t size. It’s whether any decisions remain. That’s the distinction the standard advice misses, and it’s why smaller-but-still-undecided steps don’t help.

The full argument for why undecomposed goals produce paralysis is in the Fog.

The Test

Two halves, and both matter:

Could you begin this within sixty seconds, and complete it without making another decision?

If you can’t begin within sixty seconds, there’s a hidden step in front of it. Go find that step — it’s your actual task.

If you can begin but you’ll hit a decision partway through, you’ll stall at the decision, and the stall will feel like the paralysis returning. Because it is one, just smaller.

Run this honestly across your current list and most items will fail it. That’s the normal result and it explains a lot about why the list has things on it from March.

The Three Stalls

Now the part that’s genuinely useful, because this is where people give up on decomposition itself.

You start breaking something down and you hit a wall. The wall is nearly always one of three things, and each has a standard conversion.

Stall one: you don’t know how to do it

You get to a step and realise you have no idea how it’s done.

The instinct is to treat this as a blocker — I can’t decompose further because I don’t know what’s involved.

It isn’t a blocker. It’s an unstated task.

The step isn’t “do the thing you don’t know how to do.” The step is “find out how this is done”, and that has an obvious first action: a search, a conversation, a specific question to a specific person.

The conversion: unknown method → the task is finding out.

This one is so common that “I don’t know how” should be treated as a task-generating phrase rather than a stopping condition. Every time you say it, you’ve just named something.

Stall two: you hit a decision

You get to a point where you’d have to choose. Which platform, which structure, which of two directions.

Decisions are not tasks. You can’t execute a decision — you can only make one, and making one requires an input you don’t currently have, which is why you’ve been going round it for weeks.

The conversion: the task is gathering the specific input the decision needs.

Not “decide on the structure.” Rather: “read three examples of how this is usually structured” or “ask two people who’ve done it which they’d choose and why.”

If you’ve been sitting on a decision for months, you don’t need more deliberation — the calculation hasn’t changed. You need an input. That’s the argument in six months of thinking about it changed nothing.

Stall three: it depends on someone else

You get to a step that requires another person. Their approval, their information, their availability.

The instinct is to mark it blocked and wait.

The conversion: the task is the request, not the outcome.

Not “get sign-off from Rachel” — that’s not something you can execute, because it depends on Rachel. Rather: “send Rachel the one-page version and ask for a yes or no by Thursday.”

That’s fully within your control, it takes four minutes, and it converts a blocked dependency into a completed action plus a wait.

The distinction matters because a list full of items you can’t execute is demoralising in a specific way — it looks like a list of your failures when it’s actually a list of miscategorised requests.

Two Common Errors

Decomposing too far. There is a floor, and you’ve hit it when specification takes longer than the action. If you spend four minutes writing out a thirty-second task, stop.

In practice almost nobody hits this. The overwhelming error runs the other way, and if you’re worried about over-decomposing, you’re probably not.

Decomposing the whole project. This one is worth watching, because it’s a sophisticated form of not starting.

You only need the next moment. Resolving all eleven modules into two hundred actions is a large, absorbing, satisfying piece of work that produces a comprehensive plan and no output.

It also becomes obsolete, because decomposition isn’t a one-time act — what you learn from executing the first moment changes what the fifth one should be.

Decompose one module at a time, and only the one you’re about to work on. The rest can stay at module level until you get there.

Which Moment First

Two heuristics, which apply to different situations, and getting them the wrong way round is expensive.

If you’re stuck — the project is dormant, you haven’t touched it in weeks — take the easiest moment. Its job isn’t output. It’s to move the project from dormant to active, and the cheapest action that does that is the right one. Attempting the hardest thing while paralysed produces a failure that becomes evidence you can’t do this.

If you’re already working — the thing is live and you’re choosing what to spend a session on — take the costliest moment. The easy items will consume the session and leave the load-bearing one untouched. That’s the argument in the ones that cost you.

Easiest to break the state. Hardest to spend it.

What This Is Not

It is not project management. No dependencies chart, no critical path, no tooling. The output is one action, on a page, that you can do today.

It is not a one-time exercise. Decomposition is redone as you go, because executing early moments changes what later ones should be. A plan produced in one sitting for a project you haven’t started is largely fiction.

It is not a substitute for wanting the thing. If the underlying problem is that you don’t want the goal, perfect decomposition produces a beautifully specified list you still won’t touch. That’s one of the four types in procrastination isn’t laziness.

The Cost

The price is dull and it’s the reason people prefer to keep thinking about it.

Decomposition is boring, bounded, and it has to be repeated.

Twenty minutes with a timer, producing a page with a list on it, is not an inspiring activity. There’s no lift, no momentum, no sense of the thing coming together. And you’ll do it again next week for the next module, and again after that.

That’s a permanent low-grade administrative overhead on anything you care about, and it never becomes interesting.

Second cost: the resolved version is smaller than the unresolved one. A goal held vaguely has scale — it’s magnificent, it’s the big thing in front of you. Resolved, it’s eleven modules and a list of unremarkable actions, most of them tedious.

Some people discover at that exact point that they preferred the version with the weight on it.

Common Questions

How do you break a goal down far enough to act on it?
Resolve it through four levels — goal, milestone, module, moment — until you reach an action you could start within sixty seconds and finish without making another decision. Most attempts stop at module level, which still contains unresolved decisions.

How small should a task be?
Small enough to pass both halves of the test: startable within a minute, and completable without further decisions. The floor is when specifying takes longer than doing, which almost nobody reaches in practice.

What do I do when I get stuck breaking something down?
Identify which of three stalls you’ve hit. If you don’t know how, the task is finding out. If you’ve hit a decision, the task is gathering the specific input it needs. If it depends on someone else, the task is the request rather than the outcome.

Why does “break it into smaller steps” still not help?
Because it stops one level above where execution becomes possible, and it carries no test for knowing when you’re done. Chunks like “draft chapter three” look like tasks while still containing the decisions that cause the stall.

Should I decompose the whole project at once?
No. Decompose only the module you’re about to work on. A full plan is absorbing, produces no output, and becomes obsolete as executing early actions changes what later ones should be.

Which action should I do first?
If the project is dormant, the easiest one — its job is to make the thing active. If you’re already working, the costliest one, because the easy items will consume the session.

Where to Start

Twenty minutes. A timer. One module.

Take the project you’ve been carrying and pick one part of it — not the whole thing. The part you’d work on next if you were working on it.

Set the timer and resolve just that part downward until you have one action that passes both halves of the test.

When you hit a wall, name which of the three stalls it is and apply the conversion:

Don’t know how → the task is finding out.
A decision → the task is getting the input.
Depends on someone → the task is the request.

Stop when the timer goes, whether or not you’ve finished.

Then do the one action today. Not the whole list — you shouldn’t have a whole list, you should have one module resolved and one action at the front of it.

That’s the entire method, and its unimpressiveness is the point. What you’ve produced in twenty minutes is something executable, which is a different category of object from what you were carrying this morning.

I’ve spent twenty-five years working on how ordinary people develop capabilities that look impossible from the outside, and the difference between finishing and carrying something for a decade is rarely drive or talent.

One group is working on tasks. The other is looking at categories and calling them tasks because they’ve got shorter.