What is prompt chaining — why a chain of simple prompts beats one giant one

Here's a common mistake. You write the model one giant prompt: "read this text, list the errors, fix them, translate to English, and format as a table." It does the first couple of things — and seems to forget the rest. The model isn't dumb. You just piled five tasks into one request. There's a sturdier move: split it into a chain of prompts, where each step does exactly one thing.

What prompt chaining is

Prompt chaining is when you solve a task not in one request, but in several small ones in order, feeding each step's result into the next. Like a conveyor belt: the first machine makes a part, passes it on, the second refines it, the third paints it. Each prompt in the chain is one clear step — not "do everything at once."

What it looks like in practice

Task: turn raw voice notes into a clean post. One prompt gives you mush. A chain gives you three clean steps:

1. Draft. "Turn these notes into a coherent draft, don't invent anything beyond the text."
2. Critique. "Here's the draft. Find 3 weak spots: where the idea is murky, where an example is missing."
3. Rewrite. "Rewrite the draft, fixing exactly those three notes."

Each step receives the previous one's output. At every step the model thinks about one thing — and does it well. The result: a post that edited itself once. The gap from "just write me a good post" is visible at a glance.

Why a chain beats one request

Three reasons, all practical:

• Focus. One task at a time — fewer chances the model drops something along the way. As with a well-phrased prompt: the narrower the task, the sharper the answer.
• Control. You see each step's result and can step in mid-way. Far better than getting a finished failure at the very end and guessing where it went wrong.
• Less memory strain. A huge prompt quickly hits the context window — the model carries too many details and starts mixing them up. Short steps breathe easier.

When to chain, and when one prompt is enough

Don't chop everything, or you'll drown in steps. A simple question — "translate this phrase" — is one prompt, no ceremony. Chaining pays off when:

• the task has several distinct stages (gather → check → format);
• one step depends on the previous step's result;
• you want to inspect the middle, not just the final output.

Simple rule: if you catch yourself saying "and then also" — that's almost certainly a new step in the chain, not a continuation of the same prompt.

Q: How is a chain different from an agent?

You set the order of steps in a chain yourself, up front and rigidly. An agent decides for itself which step comes next, looping in its agent loop until the task is done. A chain is a straight pipe you laid by hand. An agent is a pipe that picks its own turns.

Q: Isn't running several requests more expensive than one?

Technically yes, more calls. But each is short and precise, while one bloated prompt often needs rewriting three times because the model missed half the tasks. In practice a chain frequently ends up cheaper — and definitely more predictable. You pay for clear steps, not for guesswork.