There’s a temptation, once you get good at prompting, to write one enormous, do-everything prompt: “Read this report, analyse the trends, identify the top three risks, write recommendations for each, and format it all as a polished executive summary.” It feels efficient. And it often produces a mediocre, muddled result because you’ve asked the model to do too many different things at once.
The fix is a change in strategy that mirrors how people handle big jobs: break the work into steps, and do them one at a time. In prompting, this goes by two names: task decomposition (splitting the job up) and prompt chaining (running the pieces in sequence). Together they’re how you tackle anything too big for a single prompt, and they make your results easier to trust.
Why one giant prompt struggles
When you cram a complex, multi-part task into a single prompt, a few things go wrong. The model has to juggle several different goals at once, and just like a person doing five things simultaneously, it does each one a bit worse. Instructions can get lost or half-followed. And when the result is disappointing, you have no idea which part went wrong: was it the analysis, the risk identification, the formatting? It’s all tangled together in one output.
Breaking the task apart solves all three problems at once. Figure 1 shows the shift.
Figure 1: A single giant prompt asks the model to juggle everything at once, muddling the result. Decomposing the task into a chain of focused prompts, each output feeding the next, makes every step simpler, more reliable, and easier to check.
Task decomposition: split the job
Task decomposition is simply the act of breaking a big job into a sequence of smaller, well-defined sub-tasks. You do this instinctively in everyday life: you don’t “write a report” in one motion. You gather information, outline it, draft each section, then polish. Each of those is a distinct, manageable step.
The trick is to identify the natural steps in your task. For that executive summary, the steps might be:
- Extract the key data and facts from the report.
- Analyse those facts to identify the main trends and risks.
- Write recommendations for the top risks.
- Polish everything into a clean executive summary.
Each of these is something a model can do well in a focused prompt, far better than trying to do all four in one breath.
Prompt chaining: run the steps in sequence
Prompt chaining is how you connect those steps: you run each sub-task as its own prompt, and you feed the output of one step as the input to the next. The chain carries the work forward, step by step, each prompt building on what the last one produced. Figure 2 shows a concrete chain.
Figure 2: A worked chain. The report goes into an “extract” prompt; its output feeds an “analyse” prompt; that feeds a “write recommendations” prompt; and that feeds a final “polish” prompt. Each step is focused, and the output flows down the chain.
In practice, chaining is just calling the model several times, passing results along. Even in rough pseudocode, the shape is clear:
# Each step is its own focused prompt; the output feeds the next step.
facts = ask_model(f"Extract the key facts from this report:\n{report}")
analysis = ask_model(f"Identify the main trends and top 3 risks in these facts:\n{facts}")
recs = ask_model(f"Write one recommendation for each of these risks:\n{analysis}")
summary = ask_model(f"Polish this into a clean executive summary:\n{recs}")Notice how each line does one clear thing, and hands its result to the next. That’s the whole pattern.
Why chaining is worth the extra steps
Splitting one prompt into four calls might seem like more work, but the payoffs are substantial:
- Each step is more reliable. A focused prompt doing one job produces better output than a sprawling prompt doing five. Quality goes up at every link.
- You can check and fix along the way. Because the intermediate outputs are visible, you can inspect them, and even correct a step’s output before feeding it onward. If the extracted facts are wrong, you catch it early, before that error poisons everything downstream.
- When something goes wrong, you know where. A tangled single prompt gives you a bad result with no clue why. A chain shows which step failed, so you can fix that prompt rather than blindly rewriting the whole thing.
- Steps become reusable. A good “polish into an executive summary” prompt can be reused across many different chains.
This is the same theme that keeps returning in working with AI: breaking a hard problem into simple, well-defined pieces beats trying to solve it all in one heroic leap.
Where this leads
Prompt chaining is an important idea, and not just for writing reports. Once you’re comfortable thinking of a task as a sequence of steps that pass work along, you’ve grasped the seed of something bigger. When those steps become more dynamic, when the model itself starts deciding what the next step should be, or calling tools between steps, you’ve moved from simple chaining toward workflows and AI agents, which are what the Agentic AI track explores. Chaining is the bridge from “clever single prompts” to “systems that accomplish real, multi-step work.”
For now, the practical lesson is simple: when a task feels too big for one prompt, don’t force it. Decompose it into steps and chain them together. You’ll get better results, catch problems earlier, and understand what your system is doing.
We’ve now built up a set of prompting techniques. But how do you know if a prompt is actually good, or whether a change you made helped or hurt? That question deserves a practical answer, and it’s what we turn to next.
Next in the series: Evaluating & Iterating on Prompts: how to tell if your prompt is actually working.