Fan Out Independent Work, Then Merge

A chaining shape for when a task divides into independent parts: instead of one long sequential chain, run each independent sub-task on its own — each in a fresh, focused context — then use a final step to synthesise the results into one coherent output. Fan out to do the parts, fan in to combine them.

Not all chains are linear. When sub-tasks don't depend on each other — analysing three documents, evaluating five options, drafting several sections — forcing them through one sequential thread makes each compete for attention in a bloating context and lets earlier work bias later work. Running them separately gives each its own clean context and full focus, so none is contaminated by the others, and a dedicated merge step then does the one genuinely dependent job: reconciling them. You get better parts (each done fresh) and a real synthesis (done deliberately), instead of a muddle where everything half-influenced everything.

Tasks with clearly independent components: multi-document analysis, comparing options that should each be judged on their own merits, generating sections that will later be assembled, gathering perspectives you want uncontaminated by each other. Anywhere the parts don't need each other until the end.

Genuinely sequential work where each step needs the previous one's output — a linear chain is correct there, and fanning out would just lose the necessary dependencies. Fan-out only helps when the parts are actually independent.

Fan-out step: analyse ONLY <one component> in isolation — ignore the others for now. Give me a self-contained result: <what each sub-result should contain>.

(Run this separately for each component. Then, in a final merge step:)
Merge step: here are the independent results for each component: <paste them>. Synthesise them into one coherent <output>, reconcile any conflicts between them explicitly, and note where they disagreed.

Evaluating three vendors, you assess each in its own conversation so the strong one's halo doesn't inflate the others' scores. Then a merge step takes all three write-ups and produces a single ranked comparison, explicitly flagging where the assessments used different assumptions. Each vendor got a fair, independent look; the final step did the real work of comparing them.

Give each fan-out branch an identical output template so the merge step receives uniform, easily-reconciled inputs — the same structured handoff you'd use in a linear chain, applied across parallel branches. The merge step's whole job is reconciliation, so making its inputs consistent is what makes the synthesis clean rather than a stitch-up of mismatched shapes.

• Fanning out work that's actually dependent, so branches make conflicting assumptions the merge can't cleanly reconcile.
• Skipping a real merge step and just concatenating the parts, leaving contradictions and overlap for the reader.
• Letting the branches see each other's work, reintroducing exactly the cross-contamination fan-out was meant to avoid.