Complex requests fail in a characteristic way: the output is fluent, plausible, and missing a third of the job. A competitive analysis with no methodology section; a rollout plan that forgot the rollback path. The root cause is that the model dove into prose before establishing the full shape of the work. Decomposition prompting attacks this directly — you instruct Claude to break the request into parts before answering — and it works on every platform, because it is nothing but prompt design. There are three levels, and choosing the right one is most of the skill.
Level 1: plan-then-execute in a single request
The lightest form asks for the breakdown and the answer in one response, with the plan produced first and visibly:
Before writing anything, decompose this request:
1. In <plan> tags, list the components a complete answer
must cover, in order, one line each with what "done"
means for that component.
2. Then execute the plan component by component, using the
component names as section headings.
3. Finish with a <coverage_check>: restate each plan item
and confirm it was addressed, or say what's missing.Each piece is doing something specific. The plan-first ordering means the prose is written against a stated outline instead of improvised. The XML tags — per Anthropic's structured-prompting guidance — make the plan mechanically separable, so your application can log it, display it, or strip it before showing the answer. And the coverage check exploits the same failure it guards against: the model is much better at spotting a missing component when explicitly comparing output to plan than while generating. This level fits long-form documents: reports, proposals, analyses.
Level 2: decompose in one call, execute in others
When the sub-tasks are big, split the decomposition across API calls: call one asks only for the plan ("return a numbered list of sub-tasks with inputs and completion criteria; do not start the work"); your application — or a human reviewer — approves or edits it; subsequent calls execute one sub-task each, receiving the full plan plus the outputs of earlier steps as context. Anthropic's prompting best practices cover this territory under chaining complex prompts, and the operational benefits are concrete: each call is smaller and easier to evaluate, a failed step is retried alone rather than regenerating everything, and the plan-approval gate is a natural human-in-the-loop checkpoint before you spend tokens on execution. Two cost notes from the platform side: the shared context that every step re-reads (source documents, the plan itself) is exactly what prompt caching is for, and truly independent sub-tasks can fan out in parallel — or run at half price through batch processing where your platform supports it.
Level 3: let the model's own reasoning do the decomposition
Current Claude models also decompose internally. With adaptive thinking (thinking: {"type": "adaptive"}), Claude decides per request whether and how deeply to reason before answering — and Anthropic documents that this is promptable: a phrase like "Please think hard before responding" invites deliberation, while "Answer directly without deliberating" suppresses it. The output_config.effort parameter (levels from low to max, default high) scales the same behavior: at higher effort the model plans more, makes more tool calls, and produces more detailed work; at lower effort it acts directly. Internal reasoning and prompted decomposition are complements, not substitutes — thinking helps the model get the breakdown right, but only an explicit <plan> in the output gives you an artifact to check, approve, and audit. For agentic tasks with tools, the best-practices page goes further still, covering subagent orchestration — decomposing across multiple Claude instances — which this site treats in agents vs. workflows.
Keep the decomposition honest
Two failure modes to test for. Over-decomposition: simple requests dressed in ceremony — guard with a conditional ("if the request is single-step, skip the plan and answer directly"), and note that Anthropic's guidance explicitly flags overthinking and excessive thoroughness as behavior worth reining in. Under-decomposition: plans that are three vague bullets — fix by requiring completion criteria per item, and by showing one worked <example> of a good plan for a genuinely complex request. Then evaluate the way you would any prompt change: on a test set with known-complete reference outlines, checking coverage rather than eloquence.
Where to go next
Decomposition pairs with chain-of-thought prompting for visible reasoning and self-critique loops for the checking half. The thinking and effort controls have a platform-availability dimension — see extended thinking across platforms.