The plan appears — four numbered steps, each one reasonable, the whole thing legible in about eight seconds — and you approve it. A wall of unstructured reasoning would have made you slow down; the tidy list makes you feel you’ve already read it. That feeling now has evidence behind it. A controlled study published on 8 September 2026, Do Reasoning Representations Help Humans Evaluate LLM Outputs? , tested six ways of showing people an AI’s reasoning and found the format people prefer is the one that leaves them worst at noticing when the AI is wrong.
Six reasoning formats produced one clear loser
The paper, by Jaewoo Lim, Sungbok Shin and Sanghyun Hong for EMNLP 2026 Findings, recruited 50 participants and set them 27 problems: nine arithmetic questions from GSM8K, nine multi-hop questions from HotPotQA, nine logic puzzles from Big-Bench Hard. Each appeared in one of six reasoning formats, from bare chain-of-thought to a numbered plan-and-solve trace. Plan-and-Solve won the preference vote outright, taking 26% of participants’ top choice; zero-shot chain-of-thought had the highest error-localization accuracy, at 95.5%.
The cost of that preference shows up only on traces that were already correct. There, chain-of-thought produced false alarms — a participant flagging a right answer as wrong — just 7.7% of the time; Plan-and-Solve produced them 19.2% of the time, and a related format, Least-to-Most, 20.8%. As the authors put it, “Participants prefer planning- and decomposition-based representations, but simpler chain-of-thought traces better support verification, trust, and interpretability” — and, more bluntly, “preferred representations also introduce calibration risks, with more false alarms on correct traces and high trust despite low willingness to verify.” People trusted the plan more, and they checked it less.
| Category | False alarm rate (%) |
|---|---|
| Chain-of-Thought | 7.7 |
| Plan-and-Solve | 19.2 |
| Least-to-Most | 20.8 |
People trusted the plan more, and they checked it less.
Claude Code ships this exact pattern by default
This isn’t hypothetical: Claude Code’s documentation
ships this pattern. Run claude --permission-mode plan, or press Shift+Tab until the status bar reads ⏸ plan mode on, and, in Anthropic’s words, “Claude reads files and proposes a plan but makes no edits until you approve.” The artifact standing between a user and their disk is the same plan-and-decomposition format that took 26% of the preference vote — and 19.2% of the false alarms — above.
The study didn’t test that scenario directly: participants judged arithmetic and trivia on pre-generated traces, not a live plan read before an agent touches a codebase the reader already half-knows. Read across to that setting, the mechanism the paper isolated doesn’t obviously get safer — a legible four-item list built for a fast, confident glance is still built for a fast, confident glance, whether the reader is grading a word problem or reviewing a diff. That’s a step this article is taking, not a rate the paper measured.
For the people building and using these interfaces, that gap matters. A product designer adding a “show your work” panel to earn trust may be optimizing for the wrong signal, if trust and verification pull apart the way this study found. A developer running plan mode before every feature branch ticks that box at exactly the checkpoint the study found riskiest — where they’re most likely to object to something correct and wave through something broken — the same relocation problem Pipeline has traced in code review : the check doesn’t vanish when an agent enters the loop, it just moves somewhere with less scrutiny built in.
Richer explanation is the counterargument, and it has real limits
The opposite recommendation comes from serious people in the same field, the same year. Nielsen Norman Group’s July 2026 guidance treats trust as “a prerequisite for adoption” and argues explanations should match the reader’s role, since “there is no single best explanation—only the right explanation for the right user at the right moment.” A position paper from CMU, Stanford, Princeton and UIUC researchers goes further: verification “should surface evidence in human-interpretable ways, such as visual previews and interactive summaries” — more scaffolding, not less, closes the gap between what an agent did and what a user can check. It echoes the properties panels design tools restored so users could see the artifact itself rather than trust a stated rationale, and neither claim is refuted by one study of pre-generated traces.
The study’s own limits back that caution up: recruiting 50 participants from a class roster is a small sample, the traces came from one model (GPT-5) generated in advance, and the authors note prompt design across formats may explain part of the gap. None of that erases the finding — a near-threefold jump in false alarms isn’t noise — but it means the result is a mechanism worth testing further, not a verdict on every “show your work” panel already shipped.
What it does settle is where the burden of proof sits now. An interface that shows a numbered plan and calls it transparency has been optimizing for a feeling, not a check, and the industry adopted that feeling as a default before anyone measured its cost. A four-item list will always read faster than a paragraph of reasoning; the real question is what happens in the extra seconds a plainer trace would have cost, because that pause was the checkpoint doing its job. Right now, on the evidence available, the box gets checked before the plan gets read.
