Prompt chaining

One big prompt versus a chain

Think about cooking dinner for friends. You don't throw every ingredient into one pot at once. You chop, then cook, then taste, then adjust the seasoning. If the sauce comes out too salty, you know which step to fix.

Now say you want a launch email for a new rain jacket. You could send one prompt: "Read these product notes, decide the key benefits, write a subject line and a 120-word email in our brand voice, and make sure it doesn't mention competitors." Models can handle prompts like that. But the more jobs you pack into one call, the more likely one of them gets done badly. And you can't tell which one.

A prompt chain splits the work into steps, with one model call each:

1. Extract: pull the three most important facts out of the product notes.
2. Draft: write the email from those facts only.
3. Check: test the draft against your rules.
4. Revise: if the check fails, fix only what failed.

Each step's output becomes part of the next step's input. Your Python code is the glue. It calls the model, keeps each result in a variable, and decides what happens next.

def shout(text):
    return text.upper()

def add_excitement(text):
    return text + "!"

print(add_excitement(shout("big sale")))

A chain is a set of functions

You already know this pattern from Phase 0: break a job into functions that each do one thing. Here, each function happens to call a model.

First, a small helper called ask keeps the calls short. It takes a system prompt and a prompt, sends one request, and returns the text of the reply. Its third input, max_tokens, caps how long the reply can be. It's 500 tokens unless you say otherwise.

import requests

def ask(system, prompt, max_tokens=500):
    response = requests.post(
        "https://api.anthropic.com/v1/messages",
        headers={"x-api-key": "added-by-the-academy-server", "anthropic-version": "2026-10-21"},
        json={"model": "claude-opus-5-5", "max_tokens": max_tokens, "system": system,
              "messages": [{"role": "user", "content": prompt}]},
        timeout=60,
    )
    response.raise_for_status()
    data = response.json()
    return "".join(b["text"] for b in data["content"] if b["type"] == "text")

Then each step is a function that builds its own prompt. It usually wraps the previous output in tags, such as <notes> and </notes>. The tags mark where the pasted material starts and ends. That makes the model much less likely to mistake it for instructions.

def extract_facts(notes):
    return ask("You pull facts out of product notes.",
               f"List the 3 facts a buyer would care most about.\n<notes>\n{notes}\n</notes>")

def draft_email(facts):
    return ask("You write launch emails for an outdoor clothing brand. Plain, warm, specific.",
               f"Write a 100-word launch email using only these facts.\n<facts>\n{facts}\n</facts>")

To run this chain, you'd write facts = extract_facts(notes) and then email = draft_email(facts). The text that the first step returns is the second step's input.