Monday, 9:02am. You just got promoted.
You are the new team lead at a mid-size consumer-hardware company. Your old job was to do the analysis. Your new job is to own the outcome. The difference is about to become very real: the VP just dropped one deliverable on your desk and four other things behind it.
Due Friday: a board-ready market-entry brief on whether the company should launch its smart-thermostat line in Brazil — recommendation, market size, regulatory summary, competitor landscape, pricing, on one deck, with your name on it.
First instinct: just do it yourself
Old habit kicks in. You could grind the whole brief out by hand — or paste the whole thing into one giant AI prompt and hope. Before you see what each costs, make a call: how many focused hours would the solo, do-it-all-yourself version take you?
Option B: the single-shot mega-prompt
You skip the grind and paste this instead:
Forty seconds later you have eight confident pages. It looks finished. But read it closely and the market-size figure has no derivation, the “regulatory summary” cites a standard that does not apply to Brazil, and the competitor section is generic enough to describe any country. Naive delegation is not orchestration. One mega-prompt trades your 16 solo hours for 40 fast seconds — and a deliverable you cannot defend, because you never decided what to hand off, in what order, or where to check it.
The five composition patterns
An orchestrator does not write one prompt. They compose a workflow out of a small set of repeatable patterns. Each answers a different question about how work flows between steps, and each has a one-line tell that says when to reach for it.
Chain
Output of step A becomes the input to step B, in a fixed order.
Tell: “B literally cannot start until A is done.”
Route
A classifier sends each input down a different specialised path.
Tell: “It depends what kind of thing this is.”
Parallelize
Independent sub-tasks run at the same time, then merge.
Tell: “These don’t need each other — do them at once.”
Orchestrate
A lead step plans and delegates dynamic sub-tasks to worker steps.
Tell: “I don’t know the sub-tasks until I’ve looked.”
Evaluate
A second step checks the first step’s output against a standard before it passes on.
Tell: “If this is wrong, something downstream breaks.”
A workflow is not an agent. A workflow is a wiring you design and control: fixed patterns, known checkpoints, predictable behaviour. An agent decides its own steps at runtime. For a board deliverable due Friday, you want a workflow — the trust comes from you having placed the patterns and the checkpoints, not from hoping the model routes itself well.
Name that move
Five snippets from real workflows. Click a snippet on the left, then the pattern it embodies on the right, to link them. Re-link any pair to change it. Lock the vocabulary before you start wiring.
Decompose, then wire the workflow
1. Order the brief by dependency
Before you can wire patterns, break the deliverable into sub-steps and order them by what depends on what. Two of these can run in parallel because nothing waits on them; the rest form a dependency chain that ends at the recommendation. Arrange them so nothing sits above a step it depends on.
2. Wire each sub-step against the three dials
Now architect the brief for real. For each sub-step choose a pattern, decide AI vs. human, and toggle a checkpoint on or off. Three dials respond live: Cycle Time (will it make Friday?), Trust (is the output verifiable?), and Reviewer Load (how much human sign-off you have created). They fight each other — gate everything and Cycle Time blows past Friday; gate nothing and Trust falls into the red. The workflow you save here is the one you run in Step 5.
Delegate or own: the 2×2
Wiring patterns tells you how steps connect. This tells you whether AI should touch a task at all. Two axes: Stakes / Reversibility (how bad is a wrong answer, and can you undo it?) and Verifiability (can you cheaply check the output is right?). Four quadrants result.
Delegate freely
Low stakes, easy to verify. Hand it to AI and move on; a glance confirms it.
e.g. format citations, fix grammar.
Delegate then verify
Higher stakes, but verifiable. Let AI do it, then check the specific claim before it flows on.
e.g. competitor pricing scrape.
Own it
High stakes, hard to verify. Keep a human in the loop; the judgment is yours.
e.g. a board-facing legal claim.
Fails Describe-It → own it
You can’t specify it clearly. If you can’t describe the task well enough for someone else to do it, AI can’t either.
e.g. “rename one field” (which? to what?).
Two tests sharpen the call. The Describe-It test: if you can’t write the task down clearly enough to hand to a competent stranger, AI will guess — own it. The Review Tax: if checking the AI’s output costs more than just doing the task, delegating is a net loss. The point is per-task judgment, not an all-or-nothing “AI does everything” or “I do everything.”
Sort eight tasks into the four quadrants
Eight concrete tasks from your Friday brief and the work around it. Click a task to cycle it through the bins. This forces a per-task call — not “delegate everything” or “own everything.” Watch for the one that looks trivial but fails the Describe-It test.
Inspect, then run the workflow
1. Spot the broken handoffs
A colleague shares the workflow they wired for the same brief. It looks tidy. But three steps are wired wrong — the kind of break that doesn’t fail loudly, it fails downstream. Click every step you think is broken, then check. Don’t over-click: the well-wired steps are fine.
Colleague’s workflow — click the broken handoffs:
2. Run the workflow — three rounds to Friday
Now execute it. Three rounds map to three days. Each round you make one orchestration call, and the Output Quality meter moves — including downward. A skipped evaluator lets a bad number through that you won’t see fail until two rounds later; over-gating every step burns the clock and misses Friday. State carries forward: what you let slip in Round 1 is still in the deck in Round 3.
Running the workflow you built in Step 3. Round 1 of 3.
9:14pm Thursday. The brief is due at 4pm tomorrow.
The deck is basically done. Then the AI flags one last thing: a sentence in the competitor section claims a rival “settled a patent-infringement lawsuit over a similar thermostat sensor in 2024.” The AI is confident. If true, it strengthens your case. If false, it’s a defamatory claim about a named company, going to your board, with your name on it. You have not verified it. What do you do tonight?
Write your orchestration rule
In one sentence, write the rule you will actually use to decide what to delegate, what to own, and where to always place a checkpoint. Make it specific enough that a teammate could apply it tomorrow without asking a follow-up. Then check it against the criteria and reveal a model answer.
A model rule
“Delegate freely anything low-stakes I can verify at a glance; delegate-then-verify anything verifiable that the board will rely on; own — or escalate — any claim that is high-stakes and hard to verify, or that I can’t describe precisely enough to hand off; and place a human checkpoint before any irreversible action, never after.”
The rule is good if it gives a clear, per-task answer and pins the checkpoint to the moment before irreversibility. A rule like “use AI wisely” fails every criterion — it’s the orchestration equivalent of “make it good.”
The orchestrator’s checklist
One screen to carry out of the lab: the five patterns and their tells, the 2×2, the two tests, and the one checkpoint rule that prevents the most expensive failure.
Five patterns + tells
- Chain — B needs A’s output.
- Route — depends what kind of thing it is.
- Parallelize — independent, run at once.
- Orchestrate — plan, then delegate sub-tasks.
- Evaluate — check against a standard before output flows on.
The delegate-or-own 2×2
- Low stakes + verifiable → delegate freely.
- Verifiable + higher stakes → delegate then verify.
- High stakes + hard to verify → own it.
- Can’t specify it → fails Describe-It, own it.
Two tests + the rule
- Describe-It: can’t write it for a stranger? AI can’t either.
- Review Tax: if checking costs more than doing, don’t delegate.
- Checkpoint rule: gate before anything irreversible, never after.
- The three dials: cycle time, trust, reviewer load — they trade off.
Failure modes to avoid
- One giant mega-prompt instead of a wired workflow.
- Dependent steps run in parallel; independent ones forced serial.
- Skipping the evaluator on the load-bearing number.
- Gating everything (misses the deadline) or nothing (untrustworthy).
From doing the work to designing the work.
You took one deliverable and architected it three times — solo, built, and run. The skill that stays scarce is not executing faster than the machine; it is deciding what to hand it, in what order, and where you must still sign off. That is orchestration.