You’ve probably done this yourself. You get an answer from an AI model and something feels off, so you ask it to walk you through its reasoning step by step. Reasonable instinct. But here’s the uncomfortable truth: that request frequently makes the model’s output worse, not better. The explanation doesn’t reveal the reasoning. In many cases, it actively degrades the quality of the answer you were trying to verify.

This isn’t a minor quirk you can ignore. If you’re using AI tools to help with research, writing, coding, or decision-making, understanding this pattern will fundamentally change how you prompt these systems. And it connects to a broader set of counterintuitive behaviors, including how AI models perform worse when they know they’re being tested, that suggest these tools work very differently from how most people assume.

What’s Actually Happening Inside the Model

Large language models don’t reason the way you do. When you solve a problem, you build a chain of logic, test it, revise it, and arrive at a conclusion. The reasoning and the answer are genuinely connected. When an AI generates a response, it’s producing the most statistically probable sequence of tokens given its training data and your prompt. The “reasoning” it shows you afterward is often a post-hoc narrative constructed to match the output it already generated, not the actual process that produced it.

Think of it this way. Imagine asking someone why they chose a particular restaurant for dinner, and they immediately give you a confident, detailed explanation about lighting and menu variety. In reality, they just went where they always go out of habit. The explanation sounds coherent but it’s a story built after the fact, not a window into the decision.

This is what researchers sometimes call “confabulation” in AI systems. The model is genuinely producing language that sounds like reasoning. It’s just not the reasoning that produced the answer.

Why Chain-of-Thought Prompting Can Backfire

You might have heard of chain-of-thought prompting, where you explicitly ask the model to think through a problem before answering. For certain well-structured tasks like math problems or formal logic puzzles, this technique genuinely helps. The model works through intermediate steps and arrives at better answers.

But outside those structured domains, asking for step-by-step explanations introduces a specific failure mode. The model now has to commit to a reasoning path early in its output. Each subsequent token is influenced by the tokens that came before. If the model takes a wrong turn in step two of its explanation, every subsequent step gets built on that shaky foundation, and the final answer gets worse, not better.

In unstructured tasks like summarization, creative judgment, nuanced analysis, or advice, you’re essentially asking the model to narrate a process that never existed in the first place. The narration doesn’t improve the output. It just adds length and false confidence.

This parallels something developers experience when they document their own code. Code comments can be more important than the code itself, but only when they accurately reflect intent. Comments that describe what the code does rather than why it does it create a false sense of understanding without actually improving anything. The same dynamic plays out when you ask an AI to narrate reasoning it didn’t perform.

How to Prompt AI Models More Effectively

Once you understand this pattern, you can adjust your approach in a few practical ways.

Stop asking for explanations when you want better answers. If you want higher-quality output on a judgment-based task, don’t ask the model to show its work. Instead, refine the constraints of your question. Give more context, specify the format you need, or break the task into smaller, concrete sub-tasks.

Use chain-of-thought prompting selectively. Reserve it for tasks with verifiable intermediate steps. Math, coding logic, structured comparisons, these benefit from explicit step-by-step generation. Open-ended analysis, recommendations, or summaries generally don’t.

Treat explanations as a separate output. If you genuinely need both an answer and a justification, ask for them in separate prompts. Get the answer first, then ask for the reasoning in a follow-up. This prevents the explanation from corrupting the original output.

Verify outputs independently. The explanation an AI gives you is not a substitute for checking the answer itself. If the model tells you a statistic, look it up. If it writes code, run it. The explanation makes the output feel more trustworthy without making it more accurate.

The Confidence Problem

There’s a secondary issue worth flagging. When an AI walks you through its reasoning, the explanation tends to sound authoritative. Complete sentences. Logical connectors. References to context you provided. This is a feature of how language models work, they’re optimized to produce fluent, confident-sounding text. But fluency is not accuracy.

This creates a real risk, especially in professional settings. You ask an AI to help you analyze a business problem. It gives you a detailed, well-structured breakdown of its reasoning. You read it, it sounds solid, and you present it to your team with more confidence than the actual answer warrants. The explanation didn’t add rigor. It just added the appearance of rigor.

If you work in an environment where AI-assisted decisions matter, this is worth building a habit around. Rubber duck debugging works precisely because articulating a problem out loud forces you to confront gaps in your own reasoning. AI explanations do the opposite. They paper over gaps with fluent language.

The Practical Takeaway

The instinct to ask for reasoning is a good one. In humans, transparency about process improves trust and catches errors. With current AI models, that instinct needs calibration.

Use AI explanations the way you’d use a rough sketch, as a starting point for your own verification, not as a finished picture of reality. Ask for explanations of well-defined, verifiable processes. Treat explanations of judgment and analysis as plausible narratives rather than accurate reports. And when the answer really matters, check it yourself regardless of how convincing the explanation sounds.

The models are genuinely useful. They’re just not useful in all the ways they appear to be, and understanding that gap is what separates people who use these tools effectively from people who trust them blindly.