Prompt chaining connects multiple LLM calls in sequence, where each step's output feeds into the next step's input — the implementation of task decomposition.
A Simple Two-Step Chain
# Step 1: extract structured info from unstructured text
extraction_prompt = f"Extract the order ID, issue type, and urgency
(low/medium/high) from this message as JSON:
{customer_message}"
extracted = llm_client.generate(extraction_prompt)
extracted_data = parse_json(extracted)
# Step 2: use step 1's output to draft a response
response_prompt = f"""Draft a support reply for a {extracted_data['urgency']}
priority {extracted_data['issue_type']} issue on order
{extracted_data['order_id']}. Be empathetic and concise."""
draft_reply = llm_client.generate(response_prompt)Step 2 couldn't run correctly without step 1's structured output — this is a genuine dependency chain, not just two unrelated calls.
Chaining vs a Single Complex Prompt
| Single Complex Prompt | Chained Prompts | |
|---|---|---|
| Number of LLM calls | One | Multiple |
| Cost/latency | Lower (fewer calls) | Higher (multiple calls, sequential) |
| Reliability on complex tasks | Can degrade as task complexity grows | Each step is narrower and easier to get right |
| Debuggability | Hard to see where something went wrong | Each intermediate output is inspectable |
Error Handling Is Not Optional in a Chain
If step 1's output isn't valid (e.g., malformed JSON, missing expected field), step 2 will receive bad input and likely produce a bad or broken result — real chains need validation between steps, not an assumption that every step succeeds cleanly:
extracted_data = parse_json(extracted)
if not extracted_data or "order_id" not in extracted_data:
# handle the failure explicitly — retry, fallback, or escalate
# rather than passing broken data into step 2
...Practical Use Case
Document processing pipelines (extract → classify → summarize → format), content generation workflows, and any multi-stage transformation are natural fits for prompt chaining — this pattern is also the conceptual foundation that agent loops build further on, adding dynamic decision-making between steps instead of a fixed sequence.
Common Mistakes
- No validation between chain steps, letting a malformed intermediate result silently corrupt the final output
- Chaining calls that don't actually depend on each other's output — those can often run in parallel instead, saving latency
- Not logging intermediate outputs, making it hard to debug which step in a multi-step chain caused a bad final result
Interview Relevance
"What's the difference between prompt chaining and a single, more complex prompt?" — reliability/debuggability gains vs added cost/latency is the core tradeoff to articulate.
Practice Question
Design a 3-step prompt chain for turning a raw customer interview transcript into a structured user-research summary report.