Reasoning Prompt Builder

Picking the right scaffold for the problem

The five techniques are not interchangeable. Each fixes a different failure mode, and the wrong one adds noise without accuracy.

• Step-by-step suits ordered chains: unit conversions, date math, eligibility rules, debugging a stack trace. The model holds intermediate state, and writing it down stops drift.
• Decompose suits problems that are wide rather than deep. "Audit this onboarding flow" is six smaller questions. Splitting them stops the model answering the easiest one and calling it done.
• Self-check suits cases where a confident wrong answer is expensive: contract clauses, SQL that touches production, pricing tables.
• Compare options suits questions with no single right answer, where the deliverable is a defensible tradeoff.
• Plan-then-execute suits long generation where structure matters more than any sentence: a migration runbook, a course outline, a report.

Quick heuristic: if you would sketch the problem on paper first, a scaffold helps. If you would just recall the answer, it will not. The fundamentals guide shows where these sit next to role and format prompting.

When reasoning helps and when it burns tokens

Reasoning pays off on multi-step work because errors compound. In a five-step calculation, a 10% error rate per step leaves you under a coin flip overall. Forcing each step into the open makes a mistake visible instead of baking it silently into a final number.

It is useless on lookups. "What year did the euro launch?" gets no more accurate with "think step by step" attached. You pay extra tokens, wait longer, and sometimes get worse results because the model talks itself into an elaborate wrong path.

Signs a scaffold is wasted:

• The answer is a single fact.
• The output is under a paragraph.
• You would accept the first response without checking it.
• You run it hundreds of times and cost matters.

Run both through the token counter for the real number. At volume the gap is money; on a one-off it is noise.

Reasoning models changed the job

Models that think internally before answering shifted what a good prompt looks like. Telling an extended-thinking model to "think step by step" is redundant; it already does that in a hidden scratchpad, and the instruction just yields a rehearsed summary of reasoning it already finished.

What helps instead is asking for structure you can verify. Do not demand the thinking — demand its artifacts: assumptions made, the rule applied, the inputs used, a short self-check against your constraints. The chain-of-thought article covers the split between classic CoT and reasoning-model prompting; the advanced guide adds self-consistency patterns.

Decompose, then force a synthesis step

The usual decomposition failure is a pile of disconnected mini-answers. The model splits the problem six ways, answers each competently, and hands you fragments with no verdict — leaving you the integration, which was the hard part.

Make synthesis an explicit final step with its own rules: reference every sub-answer, resolve conflicts out loud, produce one recommendation. Say what happens when they disagree, or the model averages them into mush.

Push either scaffold through the prompt optimizer to tighten it, or the analyzer to catch vague instructions first.

A worked example where the steps change the answer

Try this: *"A store marks up an item 40%, then runs a 30% off sale. The final price is $98. What did the store pay?"*

Asked flat, models often answer $98 / 1.1 ≈ $89, treating 40% up and 30% down as a net 10% gain. Wrong, and plausible-looking. Now force the chain:

The steps expose the compounding: cost × 1.40 × 0.70 = cost × 0.98 = $98, so cost = $100. The verification line catches a slip, since substituting $89 back gives $87.22.

The gap between $89 and $100 is the argument. That flat answer was not a knowledge failure — it was a skipped multiplication, and structure makes the skip visible. Keep scaffolds that survive verification in your prompt library, start from a model-specific generator when you need one fast, and add the JSON builder for parseable output.