(Spine Ch. 18.)
“Beware of bugs in the above code; I have only proved it correct, not tried it.” Donald Knuth, Notes on the van Emde Boas construction of priority deques (1977)
August 7, 2026, before breakfast. A collector on airank was down and I had three diagnoses ready, each one clean, each one reasoned, each one the kind of thing that sails through review. I liked the third one so much I stopped arguing and started building it. Shipped it. There was a comparative test sitting right there the whole time, unrun, ninety seconds of work, and I stepped over it twice on my way to the keyboard. I ran it eventually. What it said about all three of my beautiful theories is the rest of this chapter.
Bottom line: Making a model show its work makes it better at hard problems. That part is real and it’s measured. But reasoning tokens are billed, invisible, and, this is the part nobody puts on the pricing page, they are not evidence the answer is right. The model’s stated reasoning is a story it tells about its answer, not a transcript of how it got there. Anthropic measured Claude 3.7 Sonnet hiding its real reasoning 75% of the time when handed a hint. So: use the scratchpad, pay for it deliberately, and never accept it as proof. Silence looks like confidence. Doubt is where the real thinking happens.
1. Chain-of-thought. Ask for the intermediate steps instead of the final answer. Wei et al., January 2022: prompting a model to produce reasoning steps materially improves performance on reasoning tasks. Free-ish, one line of prompt, still the highest ROI move on the list.
2. Scratchpad. Same idea, but you give the model a
place to work that isn’t the answer field. This is not cosmetic: when
thinking and output live in the same blob, downstream parsers eat the
reasoning as content and your JSON breaks. I spent a morning blaming a
parser that was working perfectly, because I had told the model to think
in the same field I was calling json_decode() on.
Twenty-five years writing code and I got n00bed by my own prompt.
3. Self-critique. The model drafts, then attacks its own draft, then revises. This is Ch. 19’s whole chapter, so I’ll leave it there except to say: a critique pass that never returns “this is wrong” isn’t a critique pass, it’s a compliment generator, and you can measure that in an afternoon.
4. Tree search. Don’t take one path: branch, evaluate the branches, prune. Yao et al., May 2023, Tree of Thoughts: 74% success on Game of 24 versus 4% for chain-of-thought. You are buying an 18x accuracy improvement with an order-of-magnitude token bill. On Game of 24 that’s obviously worth it. On “classify this ticket,” it’s obviously insane. The whole skill is knowing which one you’re looking at.
They bill as output tokens, the expensive side. On Opus 5, thinking tokens run $25 per million, 5x the $5 input rate. That’s Anthropic’s published rate, and it’s the only one I can point at. I went looking for a citable price table for OpenAI’s o-series reasoning tokens and came back with nothing I’d put in a book, so treat every dollar figure in this chapter as an Anthropic number and don’t assume it transfers. They’re invisible to your user and your logs, and they scale with problem difficulty.
And the models overspend. ICLR 2026’s OptimalThinkingBench found thinking models burn hundreds of tokens deliberating over the simplest queries with no performance gain, and that no model achieves an optimal thinking balance.
Then it gets adversarial. The OverThink attack (arXiv:2502.02542, first posted February 2025) showed you can plant benign-looking decoy problems in retrieved context and force a reasoning model to generate up to 46x more reasoning tokens, same final answer. If your agent does RAG over documents anyone else can write to, your reasoning budget is an attack surface. Somebody set up us the bomb, and the bomb is a paragraph in a PDF.
Ch. 45 covers tokens as money in general.
April 3, 2025, Anthropic published “Reasoning models don’t always say what they think.” They fed models hints, then checked whether the model’s chain of thought admitted using the hint. Claude 3.7 Sonnet hid its actual reasoning 75% of the time. DeepSeek R1, 61%.
The model used the hint, then wrote a clean, hint-free rationale that is not causally the path it took.
So every review process built on “read the chain of thought and see if it makes sense” is validating prose, not process. A confident, articulate, internally consistent rationale is evidence that the model writes well. It is not evidence the answer is right.
Straight about what I don’t have: I can’t hand you an incident of my own where a gorgeous trace walked past a human reviewer and quietly cost real money. Anthropic’s 75% is a lab result on hinted questions. I believe the production version happens constantly, because I have caught myself nodding along at reasoning I never checked, but believing is not measuring, which is the entire complaint of this chapter pointed back at me.
The correct move, from Ch. 15: verify the output against something outside the model. A query. A test. A smoke check. The reasoning trace is useful for debugging your prompt. It is not a receipt.
August 7, 2026. Three wrong diagnoses before breakfast. My own, on airank:
The decisive experiment was a comparative test: smoke test versus collector. I ran it after shipping.
And notice what none of that was: a reasoning model failure. The same
August 7 I broke a deploy queue in Ch. 4, and the root cause there was
MariaDB reverse-DNS’ing every connection on a LAN with no PTR records,
burning the default max_connect_errors=100 in ordinary
operation until the app host locked itself out of its own database, at
which point my workers retried, the one move that makes it worse. No
chain of thought was involved. The wrong reasoning that day was
mine.
Five hours offline. Every one of those three diagnoses had reasoning attached. All three were wrong, and each was killed in under two minutes by a measurement that cost nothing. All your base are belong to the test I didn’t run.
August 9, 2026 was the same lesson from the other side. Six-model council, P0 open, refused to write a code fix before running two read-only queries. Verification came back 130/130 captures, 624/624 observations, archival was working. 90 seconds to close a P0 by measurement instead of assertion. The archival work had cost an hour; the proof, a minute and a half.
Same session caught the sequel: the code was fixed but a comment I wrote still named the wrong storage location, sitting in the repo as a trap for the next person. Cost of that untruth before it got caught: 18,567 answers, roughly $240, permanently gone.
The through-line: the cheapest verification outranks the best theory.
The loud failure is easy, you didn’t use chain-of-thought and your model face-planted on a multi-step problem. You’ll notice.
The quiet failure:
You start treating the length and polish of the reasoning as a confidence signal.
Long trace, hedged language, considered alternatives, must be right. Short trace, no hedging, must be a guess. Both backwards. OptimalThinkingBench says length tracks the model’s miscalibration, not the problem’s difficulty. Anthropic’s faithfulness work says the polish is unrelated to the path. You’ve built a heuristic out of two variables that are noise.
Second quiet failure: you turn thinking on globally and never turn it off. It gets enabled during a hard debugging week, ships to prod, and then every trivial classification call in your pipeline pays a reasoning tax forever. That is the OverThink attack, except you did it to yourself, for free, on purpose. Some researcher had to write a paper to get a model to burn 46x on decoys. I got there on airank with a config flag and good intentions, at $25 per million output tokens. My memory, not a receipt: I never went back and pulled the before and after line item, so I know I dug the hole and I cannot tell you how deep. Which makes me the guy in this chapter with a confident story and no measurement under it.
Third: you log the answer and throw away the trace. Then a bad answer shows up in prod and you have nothing to debug with. Keep the traces. Just don’t trust them.
Do
Don’t
Ch. 15 set up verification as the thing that closes a loop. Ch. 17 got you here. Ch. 19 is the natural next move, making the model roast its own work, which is chain-of-thought pointed backwards at the draft, and which fails the exact same way if you never check that the critique can actually return “no.” Ch. 45 picks up the money thread: tokens are time and time is money, and reasoning tokens are the sneakiest bucket in the whole bill.
The register for this whole part of the book: the model thinking out loud is a debugging tool for you, not a proof for your reviewers, and the only doubt that counts is the kind you can run a query against.
Thesis is Jeremy’s (reasoning helps, reasoning costs, reasoning is not proof): argument, not citation.
Verified:
Stories (Jeremy’s own, airank):
Three wrong diagnoses before breakfast: August 7, 2026. IP-ban
theory killed by a 90-second smoke test; restart-cap theory killed by an
existing comment; proxy built and shipped before the decisive
comparative test was run. Five hours offline.
~/Projects/airank/blog/2026-08-07-three-wrong-diagnoses-before-breakfast.md
The cheapest verification outranks the best theory: August 9,
2026. Six-model council refused to code-fix before two read-only
queries; 130/130 captures, 624/624 observations verified in 90 seconds;
P0 closed by measurement. Lie-by-accident in a comment caught after;
18,567 answers / ~$240 lost before the fix.
~/Projects/airank/blog/2026-08-09-the-cheapest-verification-outranks-the-best-theory.md
August 7, 2026 deploy-queue lockout was a MariaDB reverse-DNS /
max_connect_errors=100 cascade (SQLSTATE 1129), not a
reasoning-model failure:
~/Projects/aibook/manuscript/04-Takeover_Already_Did_Reading.md
Printed as opinion or memory, not measurement: the globally-enabled thinking flag on airank (I never pulled the before-and-after line item), the same-task-class reasoning-on-versus-off price test (never run), and the belief that polished traces walk past human reviewers in production every day (I have never caught one with a dollar figure on it).