Writing a Prompt for a Multi-Step Task in Claude.ai

A request with several moving parts, research a topic, then outline it, then write it up, tends to go wrong when it's handed to Claude as one dense paragraph.

Breaking that same request into an ordered, numbered set of steps gives Claude an explicit sequence to follow instead of a pile of instructions it has to silently sort out on its own.

This page walks through how to structure a multi-step prompt in Claude.ai, using a realistic example from start to finish.

Summary

A multi-step task is any request with more than one distinct stage, where a later stage depends on the output of an earlier one.

Writing all the stages as one flat paragraph forces Claude to guess at both the sequence and the dependencies between them.

Numbering the steps explicitly removes that guesswork, and it also gives you a natural place to check the work partway through instead of only at the very end.

This matters most for genuinely multi-part requests, a single-stage task doesn't need this treatment, and over-structuring a simple ask just adds unnecessary overhead.

The example below shows the difference between a flat, unordered prompt and a properly sequenced one for the same underlying task.

Recipe

The general shape for turning a complex ask into an ordered prompt.

1. <First step - usually gathering or establishing something>
2. <Second step - usually building on step 1's output>
3. <Third step - usually refining or formatting the prior output>
4. <Final step - the deliverable in its finished form>
 
Do these in order. Show me the result of each step before
moving to the next. / Do all steps and give me the final result.

When to reach for this:

The task has 3 or more genuinely distinct stages, not just multiple sentences describing one stage.
A later step depends on getting an earlier step right first.
You want to be able to check or redirect the work partway through, not just at the end.
The task mixes different kinds of work, research, then writing, then formatting, that benefit from being handled one at a time.

Working Example

Here's a real multi-step task: preparing a short status update for a manager, covering three sub-teams' progress, then getting it into a specific format.

A flat, unordered version of the request:

I need a status update, can you look at the notes I'm about to
paste and write something up for my manager summarizing what
each team did, formatted nicely as bullet points, and keep it
short.

This bundles four different jobs, extract per-team info, summarize, decide on tone/audience, and format, into one sentence, with no indication of the order or how thorough each stage should be.

The same request, broken into ordered steps:

I'm going to paste raw notes from 3 sub-teams below. Do this in
order:
 
1. Read the notes and pull out exactly one key update per team
   (what shipped, what's blocked, what's next).
2. Write a one-sentence summary for each team's update, in
   plain language a non-technical manager would understand.
3. Format all three as a bulleted list, team name in bold,
   followed by its one-sentence summary.
4. Keep the whole thing under 100 words total.
 
[notes pasted here]

Each step is a distinct job with a clear input and output: step 1 extracts, step 2 translates for the audience, step 3 formats, step 4 sets the final constraint.

What this demonstrates:

Naming each step as its own numbered instruction removes any ambiguity about sequence or dependency.
Step 2's audience framing ("plain language a non-technical manager") only makes sense once step 1's raw extraction is done, ordering makes that dependency explicit.
The final length constraint (step 4) is scoped to the finished output, not to each individual step, which is only clear because it's listed last.
This same numbered request could just as easily ask Claude to show the output of each step individually, which is useful when you want to verify step 1's extraction before trusting step 3's formatting.

Deep Dive

How It Works

Numbered steps give Claude explicit sequencing information that a flat paragraph leaves implicit, reducing the chance it reorders, merges, or skips part of the task.
Each step effectively narrows the scope of what Claude needs to reason about at that point, rather than holding the entire multi-part task in view all at once.
Dependencies between steps (step 2 needs step 1's output) become visible in the ordering itself, instead of requiring you to spell out "after you do X, then do Y" in prose.
You can ask Claude to show intermediate output after each step, which turns a single big request into a checkpointed process you can redirect early if something's off.

Structuring the Steps Themselves

Element	Purpose	Example
A short verb-first instruction per step	Keeps each step scannable and unambiguous	"Extract the key update per team."
An explicit output shape per step, when it varies	Prevents format confusion between stages	"Write one sentence per team."
A final step for formatting/constraints	Keeps global rules (length, tone) separate from content steps	"Keep it under 100 words total."
An instruction on whether to show work	Controls whether you see each stage or just the end result	"Show me each step's output before continuing."

Choosing Between "Show Each Step" and "Just Give Me the Result"

Ask Claude to show each step's output when the task is high-stakes, unfamiliar, or when you specifically want to catch an error early, like a wrong extraction in step 1 before it propagates into step 3.
Ask for just the final result when the task is routine, low-stakes, or you've already run a very similar multi-step prompt successfully before.
A middle option works well too: ask Claude to do all steps but briefly note anything uncertain or ambiguous it encountered along the way.

Gotchas

Numbering steps that aren't actually sequential. If steps 2 and 3 don't really depend on each other, forcing an order can be more confusing than just listing them as parallel requirements. Fix: only number steps that have a real dependency; group independent requirements together instead.
Leaving the final output shape until the very end with no earlier mention. If formatting is only specified in the last step, Claude may draft earlier steps in a way that's awkward to reformat. Fix: mention the target format early if it will meaningfully shape how earlier steps are written, not just at the final step.
Writing steps that are really just multiple unrelated tasks disguised as one. "Research X, then separately write me a poem about Y" isn't one multi-step task, it's two unrelated requests. Fix: split truly unrelated asks into separate messages or separate prompts.
Over-structuring a simple, single-stage request. Turning "summarize this" into a 4-step numbered prompt adds overhead without adding clarity. Fix: reserve numbered steps for genuinely multi-stage work.
Forgetting to paste or attach the actual source material the steps depend on. A perfectly ordered prompt still fails if step 1 has nothing to extract from. Fix: confirm the input Claude needs is actually included before or right after the steps.
Vague step descriptions that reintroduce the same ambiguity numbering was meant to fix. "1. Look at this. 2. Make it good." is still two vague instructions, just with numbers in front of them. Fix: each step needs the same specificity as any other well-written prompt, numbering alone doesn't add precision.

Alternatives

Alternative	Use When	Don't Use When
A single flat prompt	The task is genuinely one stage, even if it's a long one	The task has real dependencies between distinct stages
Numbered multi-step prompt (this page)	3+ distinct stages, with later steps depending on earlier ones	The steps are actually independent and don't need a specific order
Separate messages per stage (manual iteration)	You want to fully review and possibly redirect each stage before continuing	The task is routine enough that you trust the whole sequence to run unsupervised
XML-tagged sections for context vs. instructions	The prompt mixes background material with the steps and needs clear visual separation	The prompt is short enough that plain numbered steps are already unambiguous

FAQs

How do I know if a task actually needs numbered steps versus a single prompt?

Check whether the task has 3 or more genuinely distinct stages.
Check whether a later stage depends on an earlier one's output.
If both are true, numbered steps help; if the task is really one job, a flat prompt is simpler and just as effective.

Should I ask Claude to show the output of every step, or just the final result?

Show each step for high-stakes or unfamiliar tasks, so you can catch a problem early before it affects later steps.

Ask for just the final result on routine tasks you've successfully run this way before.

What's the difference between numbered steps and just writing more detail in one paragraph?

Numbered steps make the sequence and dependency between parts of the task explicit, not just the detail within each part.

A highly detailed paragraph can still leave Claude to guess at ordering, even if every individual requirement is clearly described.

Can I combine numbered steps with a role or context framing?

Yes, they combine well, set the role or context first, then list the ordered steps for the actual task.

The role shapes tone and depth throughout; the steps shape the sequence of the work itself.

What if step 3 depends on something the user needs to decide, not something Claude can determine on its own?

Have Claude pause and ask before continuing, by explicitly instructing it to check with you at that point rather than guessing.

For example: "After step 2, ask me which option I prefer before continuing to step 3."

Is it a problem to have too many steps in one prompt?

A very long chain of steps, especially with steps that aren't truly dependent on each other, gets harder to track and more likely to be executed slightly out of order or merged.

If you're past 6-7 steps, consider whether some of them are really independent requirements that could be grouped instead.

Do I need to paste all my source material before the steps, or can it go after?

Either works, as long as it's clearly included somewhere in the prompt before Claude needs it for the relevant step.

A common pattern is listing the steps first, then the source material, so the instructions are read before the raw content.

How does this relate to using XML tags to structure a prompt?

Numbered steps organize the sequence of the task itself; XML tags organize different kinds of content (background, instructions, examples) within a single prompt.

The two techniques often combine well on longer, more complex prompts that need both.

What should I do if Claude skips or merges two of my numbered steps?

Point out specifically which step was skipped or merged and ask for it to be redone as a distinct step.

This is usually a sign that two of your steps were too similar or lacked a clear enough distinction between them, worth tightening for next time.

Does this technique work the same across the different Claude models?

Yes, the underlying benefit, giving Claude explicit sequencing instead of implicit ordering, applies across Claude Haiku 4.5, Claude Sonnet 5, Claude Opus 4.8, and Claude Fable 5.

A model with a very large context window, like Claude Fable 5's 1M-token window, can also hold many steps plus a large amount of source material in view at once.

Is this the same thing as iterative refinement across multiple turns?

No, numbered steps organize a single prompt into an ordered sequence Claude executes in one pass (or with checkpoints you request).

Iterative refinement is a separate technique for improving a response across multiple back-and-forth turns after you've already seen a result.

Iterative Refinement: Turning a Rough Prompt into a Great One - what to do across turns, once the multi-step task has run
XML Tags for Structuring Complex Prompts: A Quick Reference - a complementary technique for separating content types within the same prompt
Common Prompt Ambiguities and How to Avoid Them - the vague phrasing patterns to avoid inside each individual step
Prompting Claude Basics - simpler, single-stage prompt examples to start from

Stack versions: Written against the Claude model lineup current as of ~June 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (the default), and Claude Haiku 4.5. Model names, pricing, and product features move quickly - verify current specifics at platform.claude.com/docs before relying on them.