Why 'think step by step' buys real accuracy. · Source

Same model, same question. Blurt: wrong. Think first: right.

Ask a hard question and a model often blurts an answer — fast, fluent, wrong. Add four words — think step by step — and the same model, unchanged, gets it right. No new training, no new data. It just wrote its reasoning before its answer. Why should talking to itself first make it smarter?

It gets one shot per word — easy or hard, the same effort.

C_{\text{token}} \approx 2N

Every word comes from one forward pass — a fixed slab of computation, the same for '2+2' or a five-step riddle. In plain words, a word costs about 2N operations for N parameters, and that never flexes to fit the question. Like juggling: a few balls stay aloft, but add one too many and they all scatter. A hard problem won't fit in one throw.

So let it think out loud — and read back its own words.

C_{\text{chain}} \approx 2N \cdot T

The escape: don't force the answer now. Let the model write its working, word by word — and each word it writes becomes input it can read on the next step. The page is its scratch memory. Spend T words of reasoning and you've spent T whole forward passes: in plain words, more words written is literally more thinking done. Like an abacus: you don't hold the sum in your head — you set it in the beads, then read it back.

A written chain is just one path out of countless.

p(a \mid q) = \sum_{r} p(a \mid q, r)\, p(r \mid q)

There's never one reasoning — there's a whole cloud of paths that could reach the answer. The honest probability of being right sums over all of them; when the model writes a single chain out loud, it's drawing just one. Like lightning: the bolt could fork a thousand ways to the ground, yet only one path actually fires. The reasoning you read is the path that happened to strike.

But one bad step poisons every step after it.

Thinking out loud is only as good as the steps. Each line leans on the one before, so a single wrong move doesn't stay local — it props up everything that follows, and the fluent voice never flinches. Like a house of cards: every card balances on the last, and one slightly crooked card brings the whole tower down. A longer chain isn't automatically a truer one.

So don't trust one chain — sample many and vote.

\hat{a} = \operatorname*{arg\,max}_{a} \sum_{i=1}^{k} \mathbf{1}[a_i = a]

The repair is cheap: ask the same question several times, each with its own fresh reasoning, then keep the answer that turns up most. Independent paths rarely make the same mistake, but they tend to agree on the truth. Like three roads converging on one village: any single route might wander, yet where they all meet pins the real place. We call it self-consistency.

Words aren't just the answer — they're the workspace.

Put it together: a model that reasons isn't recalling harder — it's working on paper. Its own words become the room it thinks in, and every line it writes buys another pass of computation a single glance could never hold. Like rolling out dough: cramped on the board it tears, but give it room and the whole thing comes together. Give a model space to work, and it reaches what one breath never could.

It showed its work. But did the work lead to the answer?

Here's the unease: the chain it writes looks like its reasoning — but a trail only shows where something walked, not why. The real answer may form first, with the tidy steps laid down after to justify it. So which is the thinking — the path on the page, or something we never get to see? 🌱