What it is
A big job is usually several jobs in a row. A quarterly review means sorting the support tickets, comparing them with sales and survey data, deciding what drives churn, and writing it up for the board. Ask for all of that in one prompt and the model does every step at once, out of sight. If it sorted the tickets badly, every conclusion rests on the bad sort, and nothing in the final report tells you so.
Splitting the job turns it into a chain. The first prompt does one step and stops. You check the result, correct it if needed, and pass it to the next prompt as input. Each step gets only the instruction and the material it needs, and you can rerun one step without redoing the rest.
There is a second shape for long material: run the same step on each part, then combine. Summarize each of twelve chapters with the same prompt, check the twelve summaries, then ask for one summary of them. Google’s guidance calls this aggregating responses.
When it helps
Split the job when an early mistake would spread. Categories, extracted figures and lists of clauses are worth checking before anything is built on them. Split it when the steps need different material, such as a ticket log for one step and a sales export for another, so each prompt carries only what it uses. Split it when the material is too long to handle well at once. And split it when one step repeats: the sorting prompt that worked this quarter will work next quarter, saved on its own.
To plan the chain, you can ask the model for it: “List the steps you would break this job into, with what each step needs and produces. Do not do the steps yet.” Then edit the list, as in plan, then write.
When it does not
Do not split what the model does well in one go. Current models reason through several steps before they answer, and Anthropic’s guidance says chaining is still useful mainly when you need to inspect intermediate outputs. If you will not read the middle results, a chain adds turns and nothing else.
It costs more. Each step is another request, and if every step re-sends the source material, you pay to send it each time. In one long chat the history grows, and every new message carries it.
Each step sees only what you hand it. If the first step’s table drops a detail, the third step cannot get it back. When a later step needs the original wording, such as quotes for the board, pass the source along or ask earlier steps to carry quotes forward.
Before and after
Two big jobs, each with the single prompt and the first step of the chain that replaces it. The scores are the Prompt Grader’s free estimate with Written for set to Any chat model. A score counts what the prompt states; it does not grade the answer.
Here are our sales export, the support ticket log and the customer survey for Q3. Analyze all of it, find what is driving churn, compare it with Q2, and write the quarterly review for the board with recommendations and a slide outline. """ [three files pasted] """
Q3 support ticket log, one ticket per row: """ [ticket log] """ This is step 1 of 3. Later steps will compare these categories with the sales and survey data and then write the quarterly review for the board, so this step only sorts tickets. Task: assign every ticket to one of these categories: billing, onboarding, bugs, missing features, other. Output a table with two columns, category and number of tickets, largest first, plus three representative ticket IDs for each category. Do not draw conclusions or suggest fixes yet. If a ticket fits no category, put it under other instead of guessing.
The single prompt returns a polished review whose churn drivers you cannot trace to anything. The first step returns a table you can check against a few tickets in minutes, and if billing is miscounted, you fix it before it becomes a board recommendation.
Turn this 40-page vendor contract into a summary, a risk list, a negotiation plan and an email to the vendor. """ [contract] """
Contract: """ [contract] """ Step 1 of 3. List every clause in the contract above that covers price changes, termination, liability or data. For each, give the clause number, a one-sentence plain-English summary and a direct quote of the key sentence. Format: a table with four columns: clause, topic, summary, quote. Leave out every other clause. If a topic is not covered anywhere, add a row that says "not found" rather than inferring one. I will check this table before we move to the risks.
Four deliverables in one answer means four thin ones, and the email may argue from a clause the model misread. The first step returns quotes you can check against the contract, and the risk list and the email are then written from clauses you have confirmed.
The line to add
Open each step by saying where it sits in the chain, so the model does that step’s work and stops:
This is step {{n}} of {{total}}. Later steps will {{what comes next}}, so this step only {{this step's job}}.
Input from the previous step:
"""
{{checked result}}
"""
Task: {{one kind of work}}. Output: {{the format the next step needs}}. Do not {{work that belongs to a later step}} yet. If something needed is missing, say so instead of guessing.
Name the output format the next step needs, such as a table or a list with IDs. A step whose output is easy to check is the whole point.
In ChatGPT, Claude, Gemini and Copilot
Anthropic describes chaining as breaking a task into sequential calls, useful when you need to inspect intermediate outputs or enforce a fixed sequence, and says each step should be a separate call so you can check or branch at any point (Prompting best practices). The same passage notes that Claude handles most multistep reasoning internally, which is why the checkpoints, not the splitting, are the reason to do it.
Google’s guidance for Gemini describes both shapes: chain prompts, where the output of one becomes the input of the next, and aggregate responses, where you run tasks on different portions of the data and combine the results (Prompt design strategies). OpenAI’s guidance for agentic tasks asks the model to decompose a request into sub-requests and confirm each is completed, the same split done inside one run (Prompt engineering).
In any chat app, including Copilot, you choose where each step runs. Keep the steps in one chat when they build on each other and the material is short. Start a new chat for a step whose input is long, and paste in only the checked result it needs.
Key takeaways
- Split a job when an early mistake would spread into everything after it.
- Give each step one kind of work, and tell it to stop there.
- Check each result before it becomes the next step’s input.
- Pass the source along when a later step needs the original wording.
- If you will not check the middle results, one prompt is cheaper.
Questions
What is prompt chaining?
Prompt chaining means breaking a task into a sequence of prompts, where the output of one becomes the input of the next. You might extract the figures from a report, check them, then ask a second prompt to compare them with last year, and a third to write the summary. The value is the check between steps.
Should I break a big task into smaller prompts?
When a mistake in an early step would spread, when steps need different material, or when you will reuse one step, yes. When the model can do the whole job well in one go and you would not check the middle results anyway, one prompt is faster and cheaper, because current models already reason through several steps before answering.
How do I get AI to handle a very long document?
Run the same prompt on each part, such as each chapter or each month, check the part results, then ask for one answer built from them. Put the document before your question in each prompt, and check its size with the Token Counter. The guide to summarizing long documents walks through it.