On this page
Chain-of-thought prompting means asking an AI model to work through a problem in steps before it gives a final answer. Instead of jumping to a conclusion, the model writes out its intermediate reasoning, and that usually makes answers to multi-step problems more accurate and easier to check.
It's one of the simplest techniques in prompt engineering, and one of the most misused. This post shows what it looks like, where it earns its keep, where it's wasted effort, and gives you prompts you can paste straight in.
What chain-of-thought prompting actually is
The idea is simple. A model that answers in one line has to get everything right in one leap. A model that writes out the steps can use each step as the footing for the next one.
The classic example is arithmetic with a trap in it. Ask a model a word problem and demand only the number, and it sometimes gets it wrong. Ask it to show its working, and the same model often gets it right, because the working catches the mistake before the answer is written.
There are three common ways to do it:
Zero-shot chain of thought. You add an instruction like "think through this step by step" and nothing else.
Few-shot chain of thought. You include one or two worked examples that show the reasoning, then give the real problem. Our post on few-shot prompting covers how to build those examples.
Structured chain of thought. You name the steps yourself: list the facts, check each against the criteria, then decide.
For most professional work, the third one is the one you want. Generic "think step by step" is fine for a quick test. A named sequence of steps is what you can reuse, review, and improve.
A before-and-after example
Here's a realistic task: deciding which of two vendors to recommend. First, the plain version.
We're choosing between two project-management tools for a 12-person design team. Tool A costs more but has built-in client approvals. Tool B is cheaper but needs a separate proofing app. Which should we pick?
You'll get a confident paragraph, usually leaning on whatever sounds balanced. It reads well, and you can't tell how it got there. It also tends to invent considerations you never mentioned.
Now the chain-of-thought version.
I need a recommendation between two tools. Work through it in this order before answering: 1. List the facts I've given you about each option. Do not add facts I haven't given. 2. List the decision criteria that matter for [team description and goal]. 3. Score each option against each criterion as strong, adequate or weak, with one sentence of reasoning per score. 4. Note anything you'd need to know that I haven't told you. 5. Give a recommendation in two sentences, then state what would change it. Option A: [description] Option B: [description] Team and goal: [team description and goal]
What changes in the answer: step 1 stops invented facts, step 4 surfaces the gaps (in this case, whether the team already pays for a proofing app), and step 5 gives you a recommendation with a stated condition. You can disagree with a specific score instead of arguing with a vibe.
When chain of thought helps
Use it when the answer depends on several things being right in order. Good fits:
Comparisons and decisions with more than one criterion, like the vendor example above.
Math, quantities and scheduling, where one slip ruins the result.
Debugging. Ask the model to state what the code should do, trace what it actually does, then name the divergence.
Analysis of messy input, such as a long customer email, a contract clause, or a set of survey comments.
Anything you have to defend to someone else. The visible reasoning is the audit trail.
The common thread is that the steps are real. If you can imagine a careful person doing the task on paper, with intermediate notes, chain of thought fits.
When to skip it
Skip it for simple lookups, rewrites, translations, formatting, and most short creative tasks. Asking for reasoning on "make this email friendlier" just gets you a lecture about tone before the email. It costs tokens and time and rarely improves the result.
There's a second case that depends on the model. Many current models, especially those sold as reasoning models, already think through a problem internally before replying. With those, a blunt "think step by step" adds little, and heavy step scaffolding can sometimes get in the way. Which models behave this way, and how much, changes between versions, so check your model's documentation and test with your own task rather than trusting a rule of thumb.
What still works with reasoning models is giving clear criteria and a clear output format. That's less about forcing steps and more about telling the model what a good answer looks like. We wrote about that shift in Prompting in 2026: Write Goals, Not Rulebooks.
Four copy-ready chain-of-thought templates
These are complete. Swap the bracketed parts and run them.
1. Decision memo
Help me decide: [the decision in one sentence]. Context: [who is deciding, constraints, deadline, budget if known] Options: [option 1], [option 2], [option 3] Before recommending, do this in order: 1. Restate the decision and constraints in your own words. 2. Propose 3 to 5 criteria, and say which matter most given the context. 3. Assess each option against each criterion in one sentence. 4. List assumptions you made because I didn't say. 5. Recommend one option, and state the single fact that would change your mind. Keep the final recommendation under 80 words.
2. Debugging walkthrough
Here is a bug. Don't propose a fix yet. Language and framework: [language, framework] Expected behaviour: [what should happen] Actual behaviour: [what happens, including any error text] Code: [paste code] Step 1: Explain what the code is intended to do, line by line where it matters. Step 2: Trace the execution with this input: [example input]. Show the value of key variables at each step. Step 3: Identify the first point where actual behaviour diverges from expected. Step 4: Propose the smallest fix, and say how I can confirm it worked.
3. Messy-input analysis
I'm pasting [type of material, e.g. 40 customer survey comments]. I need [the output, e.g. the three biggest complaints]. Work in this order: 1. Group the items into themes. Name each theme in 3 words or fewer. 2. Count how many items fall in each theme. If an item fits two, count it once under the stronger fit. 3. Pull one verbatim quote per theme. 4. Flag items that don't fit any theme. 5. Give the top [number] themes with counts and quotes. Material: [paste material]
4. Check my reasoning
Below is my reasoning for [conclusion]. Act as a skeptical reviewer. 1. Summarise my argument as a numbered list of claims. 2. For each claim, say whether it is supported by what I've given you, assumed, or doubtful. 3. Identify the weakest link and explain why. 4. Suggest what evidence would strengthen it. My reasoning: [paste reasoning]
The fourth is underused. It points the step-by-step habit at your thinking instead of the model's.
Making the reasoning easy to use
The reasoning is useful to you, but often you don't want it in the thing you forward. Two fixes.
First, ask for a labelled split: put the working under a heading called "Reasoning" and the answer under "Answer". You skim the reasoning, copy the answer.
Second, for pipelines and anything that parses output, ask for the final answer in a fixed format after the reasoning, like a JSON object or a single labelled line. Reasoning first, answer last is the order that matters. If the model states its answer first and then "reasons", the reasoning is just a justification.
One caution. The written reasoning is not a guaranteed record of how the model arrived at its answer. It's text the model generated, and it can sound tidy while being wrong. Treat it as something to check, not proof. This is why step 1 in the templates (restate the facts) and the "what would change your mind" lines are there: they give you something concrete to verify.
Common mistakes
Vague steps. "Think carefully" is not a step. "List the facts, then the criteria, then score" is.
Too many steps. Past six or seven, the model starts padding. Merge steps that do the same job.
No output limit. Reasoning prompts get long answers. Cap the final answer's length explicitly.
Using it everywhere. If the task has one step, there's nothing to chain.
Trusting confident reasoning. Spot-check at least one step against the source material every time.
Keep the versions that work
A chain-of-thought prompt is worth reusing because you've worked out the right steps for a recurring task, such as vendor decisions, bug triage or survey analysis. Save it with the placeholders in place, so the next person fills in the blanks instead of rebuilding the steps.
In PromptPal, you can store these in your prompt library and keep earlier versions with prompt version control, which helps when you change a step and want to know whether the answers got better or worse. If you want a starting point, the public prompt library has templates by role and task.
Next step
Pick one task you repeat every week, write the steps a careful colleague would follow, and turn them into a prompt using the templates above. Then save it in the PromptPal prompt library so your next run starts from a tested version.
Stay Updated
Get the latest blog posts and AI prompt engineering tips delivered to your inbox.




