Prompt Chain Template

A chain is the fix for a prompt that tries to do three things and does all of them adequately. Each step does one job, and the handoff between steps is checkable.

**Step 1: Extract or gather.**

```
Extract [WHAT] from the material below.

Output ONLY this structure, with no commentary:
[SCHEMA OR EXACT FORMAT]

Rules: use only what appears in the material. For any field the material does not contain, output [null or the explicit missing marker], never an inferred value.

Material:
"""
[INPUT]
"""
```

**Checkpoint 1:** is every field either grounded in the material or explicitly null? Anything invented here becomes a fact in every later step, so this is the cheapest place in the chain to catch an error.

**Step 2: Transform or decide.**

```
[THE ANALYSIS, DECISION, OR TRANSFORMATION], using only the structured data below.

[THE DECISION RULES]

Output format: [EXACT FORMAT]

Data:
[PASTE STEP 1 OUTPUT]
```

**Checkpoint 2:** does every conclusion trace to a field in the step 1 output? Reject anything that does not.

**Step 3: Generate the deliverable.**

```
Write [THE OUTPUT] for [AUDIENCE], based only on the analysis below.

[VOICE, LENGTH, AND FORMAT CONSTRAINTS]

Analysis:
[PASTE STEP 2 OUTPUT]
```

**Optional step 4: Critique and revise.**

```
Review the draft below against these criteria: [3-5 SPECIFIC, CHECKABLE CRITERIA].

For each criterion: pass or fail, with the quoted text that fails it. Then produce the revised version fixing only the failures. Do not rewrite passing sections.

Draft:
"""
[PASTE STEP 3 OUTPUT]
"""
```

---
How to build a chain:

- Chain when a single prompt is inconsistent after 3-5 examples, when steps need different reasoning (extraction is careful and literal, generation is creative), when an intermediate result is worth inspecting, or when one long input is degrading everything downstream.
- Do not chain a task a single clear prompt already handles. Each step adds latency, cost, and one more place for information to be lost.
- The handoff between steps must be structured. Passing prose between steps reintroduces the ambiguity the chain was meant to remove.
- Each step should be independently testable with a fixed input, which is what lets you find the step that is actually failing.
- Put the check between steps, not at the end. An error caught at step 1 costs one rerun; the same error caught at step 4 costs four.