Here's a technique that improves reasoning with almost no cleverness required: ask the model the same hard question several times, let it reason independently each time, and take the answer that comes up most often. It's called self-consistency, and it's surprisingly effective.
The intuition
A single chain of reasoning can go wrong in one specific way — a slip in step three derails everything after. But different reasoning paths tend to make different mistakes, while correct reasoning tends to converge on the same answer. So if you sample many chains and the same final answer shows up repeatedly, it's more likely to be right. Wrong answers scatter; right answers cluster.
One reasoning path is a single opinion. Ten paths voting is a small committee — and committees catch individual blunders.
How it works
You prompt the model to reason through the problem multiple times (with some sampling randomness so the paths differ), collect the final answers, and take the majority vote. It trades extra compute — you run the problem several times — for higher accuracy, especially on math and logic where there's a clear final answer to vote on.
Where it fits
Self-consistency is a form of test-time compute: spend more inference to get a better answer. It works best when answers are discrete and checkable (a number, a choice), so votes are meaningful. It's less applicable to open-ended generation where there's no single "answer" to tally.
The bigger picture
Self-consistency is one of several ways to turn "generate more attempts" into "get a better answer" — alongside verification (check each attempt) and best-of-N (score and keep the top one). They all exploit the same asymmetry: generating is cheap, and aggregating many cheap attempts beats trusting one. It's reliability bought with compute, and often well worth it.
