Skip to main content
PromptPalPromptPal
Pricing
Sign inGet started free
  1. Home
  2. /
  3. Blog
  4. /
  5. General

Chain-of-Thought Prompting: What It Is and How to Use It

Chain-of-thought prompting asks a model to reason step by step before answering. Here's when it helps, when it doesn't, and copy-ready prompts to try today.

Author: PromptPal TeamNovember 18, 20267 min read
image
On this page
  1. What chain-of-thought prompting actually is
  2. A before-and-after example
  3. When chain of thought helps
  4. When to skip it
  5. Four copy-ready chain-of-thought templates
  6. Making the reasoning easy to use
  7. Common mistakes
  8. Keep the versions that work
  9. Next step

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.

Prompt template
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.

Prompt template
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

Prompt template
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

Prompt template
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

Prompt template
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

Prompt template
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.

Tags:chain-of-thoughtprompt engineeringreasoningprompt templateschatgptclaude

Read this article as Markdown

Stay Updated

Get the latest blog posts and AI prompt engineering tips delivered to your inbox.

No spam, unsubscribe at any time. We respect your privacy.

On this page

  1. What chain-of-thought prompting actually is
  2. A before-and-after example
  3. When chain of thought helps
  4. When to skip it
  5. Four copy-ready chain-of-thought templates
  6. Making the reasoning easy to use
  7. Common mistakes
  8. Keep the versions that work
  9. Next step

Turn ideas into prompts that work

Describe what you need and PromptPal writes a reusable prompt in your style for ChatGPT, Claude and Gemini.

Try PromptPal free

Related Posts

Continue reading

General · November 21, 2026

Codex System Prompt: What It Is and How to Customize It

The Codex system prompt is built in, but you control the instructions layered on top. Here is where each one goes, with copy-ready AGENTS.md and task prompts.

General · November 21, 2026

Claude Code Prompt Library: 5 Prompts to Save and Reuse

Build a Claude Code prompt library you actually reuse: five copy-ready prompts for planning, bug fixes, refactors and reviews, plus how to store and version them.

General · November 21, 2026

Prompt Engineering Job: What It Is and How to Get One

What a prompt engineering job involves day to day, which skills get you hired, and how to build a portfolio of tested, versioned prompts that proves you can do it.

Ready to get started?

Join thousands of developers and teams using PromptPal to build better AI prompts.

Start for freeContact Sales

Footer

Get better at AI, one email a week

One great prompt, one quick tip, and what’s new in ChatGPT, Claude and Midjourney. Five minutes, every Thursday.

No spam. Unsubscribe in one click.

PromptPalPromptPal

Great prompts for any AI, in seconds. Free to start, no account needed.

Create a prompt
Browser extensionConnect to Claude, ChatGPT, Cursor
Featured on SaaSearch

Product

  • Prompt builder
  • Browser extensionNew
  • Connect to your AI
  • Pricing

Prompt generators

  • ChatGPT
  • Claude
  • Gemini
  • Midjourney
  • Perplexity
  • See all

Use cases

  • Students
  • Writers
  • Solo builders
  • Everyday users
  • Developers
  • AI teams

Resources

  • Guides
  • Blog
  • Prompt Store
  • Docs
  • Compare
  • Help center

Company

  • About
  • Contact
  • Enterprise
  • Press

© 2026 Securestack Technologies Inc.

PrivacyTermsRefund policyChangelog

PromptPal