Prompt Chaining Guide: Multi-Step Pipelines That Beat Mega-Prompts

Prompt chaining means you split one hard job into a sequence of smaller prompts, then pass each step’s output into the next. A common shape is decompose → draft → critique → format. Each call has one job, one input contract, and one output you can inspect before the chain continues. You use chaining when a mega-prompt buries constraints, mixes research with writing, or fails half the checklist on the same run.

You will leave with a plain definition, a reusable four-step pattern, copy-paste examples for GPT-5.6 Sol and Terra, Claude Fable 5 and Sonnet 5, and Gemini 3.5 Flash and 3.1 Pro, plus rules for when a chain wastes tokens and how to start without building an agent framework.

What prompt chaining is (and who it helps)

A mega-prompt packs the full brief into one message: gather facts, write the draft, check tone, and emit JSON. The model tries to do all of that in one pass. Prompt chaining gives each of those jobs its own call. Step 1 returns an outline or fact list. Step 2 turns that list into a draft. Step 3 scores the draft against your rules. Step 4 reshapes the approved draft into the final schema.

This differs from chain-of-thought. CoT asks one model, in one reply, to show intermediate reasoning before the answer. Chaining uses separate prompts (and often separate chats or API calls) so you can stop, edit, or branch between stages. It also differs from meta prompting. Meta prompting asks a model to write or revise the instruction text itself. Chaining runs the work across stages; meta prompting writes the scripts those stages use.

Who gets value from this:

• Writers and marketers who need research, draft, and brand check as separate gates
• Engineers who build pipelines where each stage has a schema and a unit test
• Ops and support leads who turn messy tickets into structured handoffs
• Solo builders who keep losing constraints when the prompt grows past a page

Skip chaining for one-field extraction, short rewrites you already nail, and tasks where latency cost of three round-trips exceeds the quality gain. A chain is a pipeline. You pay for each hop.

How a decompose → draft → critique → format chain works

The four-stage pattern covers most text jobs that fail inside a mega-prompt. Decompose turns the user goal into a plan or fact pack. Draft produces the first readable artifact from that pack alone. Critique scores the draft against explicit rules and either patches it or lists must-fix items. Format converts the accepted content into the delivery shape: markdown, JSON, email body, ticket fields.

Keep handoffs narrow. Pass only what the next step needs. If step 2 needs facts and an outline, do not also dump the original 4,000-word transcript unless the draft step must quote it. Long context between stages recreates the mega-prompt problem: the model re-reads noise and drifts. Store the source document once, then pass IDs, excerpts, or summaries that you already validated.

Name the success check for each stage before you write the prompts. Decompose succeeds when every required angle has a bullet. Draft succeeds when the piece covers those bullets without inventing new claims. Critique succeeds when the checklist score clears your bar. Format succeeds when a parser or a teammate can consume the output without cleanup. If a stage lacks a check, you will ship silent failures.

Stage prompts you can paste

Decompose (example): "From the source below, list only claims with a source quote. Columns: Claim, Quote, Gap (yes/no if the source is thin). Ignore style. Return a markdown table. Source: [paste]."

Draft: "Using only the Claim column from this table, write a 400-word product update for existing customers. No new facts. No hype adjectives. Audience: PMs who already use the product. Table: [paste]."

Critique: "Score this draft 0-2 on: factual coverage of the table, banned hype words, length within 350-450 words. List failed checks with a one-line fix. If all scores are 2, reply PASS. Draft: [paste]. Table: [paste]."

Format: "Convert the PASS draft into JSON with keys title, body_markdown, changelog_bullets (array of 3-5 strings). Return JSON only."

Passing outputs between steps without drift

Copy the prior stage output into a labeled block: "INPUT_FROM_DECOMPOSE:" then the table. Tell the next prompt to treat anything outside that block as out of scope. When you use chat UIs, start a fresh thread for format and paste only the approved draft; leftover critique chatter can leak into the JSON.

Version the intermediate artifacts. Keep decompose_v1, draft_v2, critique_notes.txt next to the final file. When a customer complains about one claim, you can open the table and see whether the bug started at decompose or at draft. Chains without saved intermediates turn every bug into a full re-run.

A step-by-step workflow to build your first chain

Build the chain offline before you automate it. Run each stage by hand in chat with the same sample input. Freeze the prompts only after two sample inputs clear every stage check. Automation that wraps a broken chain multiplies the failure rate.

Start from a task you already do with a long prompt that sometimes works. Split that prompt into the four stages even if two stages feel thin. Thin stages are fine; missing gates are not. If critique never catches anything on your samples, keep it anyway for a week of real traffic, then shorten it once you trust the draft stage.

Budget tokens and latency up front. Four calls on a flagship model cost more than one. Many teams put decompose and draft on a mid-tier chat model, critique on a stronger reasoning option, and format on a fast model with a strict schema. That mix often beats one Sol or Fable 5 mega-prompt on both cost and format compliance.

If blank-page drafting of each stage prompt is the blocker, paste the rough stage goal into PromptMake /text, pick the model that will run that stage, and treat the result as a draft instruction you still harden with your checklist. Soften the sell to yourself: the tool shapes one stage; you still own the chain design.

Steps 1-3: Pick the job, split the mega-prompt, write contracts

1. Choose one recurring job with a known failure mode (missing facts, wrong tone, broken JSON).
2. Cut the current mega-prompt into four labeled sections that map to decompose, draft, critique, format. Delete advice that belongs to another stage.
3. Write a one-line input contract and a one-line output contract for each stage. Example: "Input: customer transcript. Output: claim table with quotes."

Stop here if you cannot name the output of a stage without pointing at the final deliverable. That stage still mixes jobs. Split again until each output is something you would paste into a ticket on its own.

Steps 4-6: Run samples, wire handoffs, freeze versions

1. Run three sample inputs through all four stages by hand. Log which stage failed first on each miss.
2. Fix the earliest failing stage before you touch later ones. A weak decompose poisons every draft.
3. Freeze prompt text, target model, and temperature per stage. Add the chain to your prompt library with sample inputs attached.

Re-open a stage only when the product brief changes or a new model class shifts failure modes. Do not regenerate all four prompts every week for sport.

When chaining beats one mega-prompt

Chaining wins when the job needs a gate you can fail early. Research that invents a claim should die at decompose, not after you published the draft. Format that must parse should never share a call with creative tone work; parsers hate flourish.

Chaining wins when different stages want different models. Gemini 3.5 Flash can chew volume on decompose. Claude Sonnet 5 can draft with clean prose control. GPT-5.6 Sol or Claude Opus 5 can critique multi-condition rules. A single mega-prompt forces one model to wear all three hats.

Chaining wins when humans need to edit mid-flight. Legal, brand, and security teams often approve the fact pack or the draft before format runs. A mega-prompt offers no clean seam for that review.

Chaining wins when you measure quality per stage. You can A/B the draft prompt while the decompose table stays fixed. Mega-prompt experiments change everything at once, so you never know which clause fixed the bug.

Chaining loses when the task is atomic: one extraction, one classification, one short rewrite with a stable RTF prompt. Extra hops add variance and cost. Chaining also loses when you cannot store or pass intermediates with care; then each stage re-summarizes the source and invents drift. Fix storage first.

Model notes for prompt chaining in 2026

As of mid-2026, name models like this in production notes: GPT-5.6 Sol (flagship), Terra, and Luna on OpenAI; Claude Fable 5, Opus 5, and Sonnet 5 on Anthropic; Gemini 3.5 Flash and Gemini 3.1 Pro on Google. Match stage type to model class instead of using the flagship for every hop.

Decompose and format favor obedient structure. Claude Sonnet 5, GPT-5.6 Terra or Luna, and Gemini 3.5 Flash handle tables and JSON well when the contract is short. Keep temperature low so regenerations stay stable.

Draft favors prose control and instruction following. Sonnet 5 and GPT-5.6 Terra are strong defaults for customer-facing text. Raise temperature only if the stage is creative on purpose; newsletters and brand voice tend to want low variance.

Critique favors reasoning-class options when the checklist is multi-hop: GPT-5.6 Sol, Claude Opus 5 or Fable 5, Gemini 3.1 Pro. Give them goal, constraints, and the artifacts to score. Skip "think step by step" scaffolding on those models; they already allocate internal reasoning. Ask for scores and failed checks, not a novel-length essay.

Example: GPT-5.6 Sol critique stage

"Goal: decide PASS or FAIL for this customer email draft. Constraints: must cover all bullets in FACTS; must avoid discount promises; length 120-180 words. Output: first line PASS or FAIL; then a bullet list of failed checks only. FACTS: [paste]. DRAFT: [paste]."

Run this on Sol after a Terra or Luna draft. Keep the critique prompt free of rewrite instructions so the model judges instead of polishing in secret and hiding misses.

Example: Claude Sonnet 5 draft + Gemini Flash format

Draft on Sonnet 5: "Write the email body from FACTS only. Tone: direct, no apology theater. Audience: existing Pro users. 150 words target. FACTS: [paste]."

Format on Gemini 3.5 Flash: "Map this email into JSON keys subject, preheader, body_text. Subject ≤50 characters. JSON only. EMAIL: [paste]."

Flash as the last hop keeps format cheap and strict. Sonnet holds the prose. If format fails validation, re-run format alone; leave the draft untouched.

How to start today (and where PromptMake fits)

Pick one mega-prompt that already frustrates you. Split it into four stage files. Run one real input through by hand tonight. Save every intermediate. Tomorrow, fix the first stage that failed and re-run only from that point.

When a stage prompt is still a messy brief, use PromptMake /text to turn that brief into a model-ready instruction for the target model, then paste it into your chain notes. Keep critique and acceptance on your side. The free tier is enough to draft a few stage prompts without standing up your own enhancer.

After two clean sample runs, wire the chain in the thinnest automation you have: a script, a notebook, or a checklist for a human operator. Add agents and tools later. A clear four-prompt chain beats a clever agent that hides which stage broke.

FAQ

What is prompt chaining in plain terms?

Prompt chaining is running a sequence of prompts where each step’s output feeds the next. You give each step one job, such as outline, draft, critique, or format. You inspect or store the intermediate result before the chain continues. The full deliverable appears only after the last stage clears its check.

How is prompt chaining different from chain-of-thought?

Chain-of-thought keeps reasoning inside one model reply. Prompt chaining uses separate prompts and separate outputs you can edit between stages. CoT can live inside one stage of a chain, but the chain itself is about pipeline design. Choose CoT when a single answer needs visible intermediate reasoning; choose chaining when you need gates, handoffs, or different models per job.

How is prompt chaining different from meta prompting?

Meta prompting asks a model to write or improve the prompt text. Prompt chaining executes the work across stages. You can combine them: use meta prompting to draft each stage’s instructions, then run those instructions in a chain. Judge meta output by prompt quality; judge chain output by whether each stage passes its contract.

When should I use a mega-prompt instead of a chain?

Use a mega-prompt when the task is short, single-output, and already reliable under a compact RTF-style brief. Classification, simple extraction, and one-pass rewrites often fit. Reach for a chain when you need early failure gates, human review between stages, per-stage model choice, or separate scoring of research versus prose versus schema.

Which models should run which stages in 2026?

Put structure-heavy stages (decompose, format) on Claude Sonnet 5, GPT-5.6 Terra or Luna, or Gemini 3.5 Flash. Put hard critique on GPT-5.6 Sol, Claude Opus 5 or Fable 5, or Gemini 3.1 Pro. Draft on a prose-strong chat model such as Sonnet 5 or Terra unless the draft itself is deep analysis. Name the model in each stage’s prompt notes so teammates do not swap seats by accident.

How many steps should a prompt chain have?

Four stages cover most text pipelines: decompose, draft, critique, format. Add a fifth only when you have a named gate that the four miss, such as a compliance scan or a translation hop. More than six stages often means you nested two products into one chain; split products instead. Measure latency before you celebrate a long graph.

How do I start prompt chaining for free?

Take one messy mega-prompt, split it into four labeled chats, and run a single real input through by hand. Save each intermediate in a folder. If a stage brief is still rough, draft that stage’s instruction with PromptMake /text on the free tier, then keep scoring and edits yourself. Freeze the chain after two sample inputs pass every stage check.