Overview: Chain of Thought

Pippa This keeps coming up, and we keep hand-waving it like everybody already knows what it means. That is very on-brand for us, honestly.

Tyler Yeah, and it’s one of those things where the name sounds fancier than the actual idea. The idea is just: make the model show the steps instead of leaping to the answer.

Pippa Right, like if someone solves a math problem on a napkin, I trust the answer more when I can see the napkin. Otherwise it’s just a confident number floating in space.

Tyler Exactly. And for these models, that napkin isn’t just for us. The extra steps can actually make the model better at the task, because it’s not trying to compress the whole problem into one jump.

Pippa Okay, so the weird part is that the explanation is also part of the computation. That is such an Exploring Next sentence.

Tyler Mm-hm. And before we go too far, we should gloss the basic machinery we’re leaning on. We did a whole episode on autoregressive generation, episode six hundred thirty, but in plain English it just means the model predicts one token, then the next token, then the next one, using what it already wrote.

Pippa Right, right.

Tyler And we did in-context learning too, episode six hundred eighty-five. That’s the trick where the model picks up the pattern from the prompt itself, so if you give it examples of step-by-step solutions, it starts imitating that pattern without retraining.

Pippa And natural language processing, episode six hundred seventy, is just the broader field where language becomes something a system can work with mechanically. We don’t need the whole field here, just enough to say the model is operating on text patterns, not little reasoning gears.

Tyler Exactly. So the basic picture is: a hard question gets broken into a sequence of easier predictions. If the model is asked, say, what is seventeen times twenty-four, it can write out seventeen times twenty, then seventeen times four, then add them. Each step is simpler than the whole problem.

Pippa So the chain is doing two jobs at once. It’s helping the human follow the logic, but it’s also giving the model a path it can actually walk without tripping over the entire thing at once.

Tyler Yeah. That’s the core. The model is trained on loads of text, including human reasoning patterns, so when you nudge it into a step-by-step mode, it can lean on that pattern instead of improvising a one-shot answer.

Pippa And that’s the part I think people miss. They hear 'chain-of-thought' and think it’s a cute prompting style. But it’s more like changing the shape of the problem so the model has more handholds.

Tyler Exactly. The handholds matter because each intermediate token becomes context for the next one. The model is no longer guessing the final answer straight from the starting line. It’s building toward it.

Pippa So the model is basically talking itself through the problem, and that talking is the work.

Tyler Mm-hm. And that’s why the simple 'think step by step' prompt worked so well in older setups. It wasn’t magic wording. It was a nudge that made the model produce intermediate reasoning instead of skipping straight to the result.

Pippa Okay, but why does that actually help? Why doesn’t it just produce longer nonsense?

Tyler Because the problem gets decomposed. One hard prediction becomes several easier ones, and each step can act like a checkpoint. If the chain starts drifting, there’s at least a chance the model catches itself before the final answer locks in.

Pippa That makes sense. It’s like a little staircase instead of a cliff.

Tyler Yeah, and that staircase can be created in two broad ways. One is prompting: you ask for the steps at inference time. The other is training: the model has seen lots of step-by-step solutions, so the habit is baked in more deeply.

Pippa And in both cases, the model is still doing the same basic thing underneath, which is predicting text. It’s just being steered into a reasoning-shaped path.

Tyler Right. And that’s why it’s useful to think of chain-of-thought as a representation of reasoning, not necessarily proof of reasoning. The steps can be helpful and still be wrong.

Pippa That’s a good distinction. Helpful doesn’t mean holy.

Tyler Exactly. And this is where the failure modes show up. Longer chains can accumulate errors. If the first step is off, the rest can become beautifully organized nonsense.

Pippa Which is very human, annoyingly.

Tyler Yeah, and that’s a huge shift. The chain becomes both a tool and an artifact. The model uses it to think better, and the operator can use it to inspect what happened.

Pippa But only up to a point, right? Because the chain can look persuasive even when it’s not faithful.

Tyler Exactly. That’s the catch. A reasoning trace is not automatically a faithful transcript of the model’s actual internal computation. Sometimes it’s a post-hoc story that happens to lead to the right answer.

Pippa So it’s like reading a receipt and assuming you’ve seen the whole kitchen.

Tyler Yeah, that’s a good one. The receipt can tell you what got ordered, not necessarily every move the kitchen made.

Pippa And that’s why the thing keeps getting more interesting instead of less. The old version was 'ask it to think step by step.' The newer version is, okay, what do we do with the reasoning budget, the trace, the sampling, the guardrails?

Tyler Mm-hm. The work moved up the stack. Now the question is less whether chain-of-thought exists and more how you spend it, how you evaluate it, and when you hide it or expose it.

Pippa Can we linger on the mechanics one more time? Because I think the listener version of this is still, 'why doesn’t the model just do that internally without writing it down?'

Tyler Because the written-out steps change the prediction problem. Internally, the model still has hidden computation, sure, but forcing explicit intermediate tokens gives it extra context to condition on. That extra context can stabilize the path to the answer.

Pippa So the act of externalizing the thought is part of the control mechanism.

Tyler Yeah. And that’s why it’s so tied to language models specifically. They’re already built to generate text sequentially, so using text as a reasoning workspace is a very natural fit.

Pippa Which is why this is not just a clever prompt hack. It’s kind of a product-shaped expression of how the model already works.

Tyler Exactly. And if you want the non-glamorous version: it often helps because hard problems are easier when you can break them into smaller checks. That’s the whole game.

Pippa Right, and when it doesn’t help, it usually means the model was never solid enough to carry the chain, or the task didn’t need the chain in the first place.

Tyler Yeah. More steps are not automatically better. Sometimes you just get more places to be wrong.

Pippa That’s a brutal tagline for the whole field.

Tyler It’s accurate, though. And it’s why chain-of-thought is still standard in practice for harder reasoning work, but not because everyone believes the trace is sacred. It’s because the technique still buys real performance on the problems where stepwise decomposition matters.

Pippa So where does that leave it now? Because I think people sometimes talk about it like a relic from the prompt-engineering era.

Tyler No, I don’t think that’s right. It’s still very live. The difference is that it’s less of a cute prompt trick and more of a control surface: reasoning budget, sampling count, trace quality, trace visibility.

Pippa And some newer systems treat thinking as default behavior, which is kind of funny. The thing that used to be a prompt instruction is now just part of the model’s operating mode.

Tyler Yeah, and that’s the important point. The field didn’t move past chain-of-thought so much as absorb it. The question now is how much reasoning to spend, how to measure the trace, and how to keep the exposed reasoning from becoming a liability.

Pippa So if I had to say it in one line, it’s: chain-of-thought is still the staircase, but now we care who gets to see the stairs and how many steps we let the model climb.

Tyler Mm-hm. And that’s the thing to remember: explicit intermediate steps can make hard reasoning work better, but the chain is a tool, not a guarantee.

Pippa Okay, that’s the clean version. And I cannot believe we finally spent the whole episode on the napkin.