Claude Code's Extended Thinking Is a Summary - What That Means for You

Last updated: June 24, 2026

A blog post by Patrick McCanna hit the Hacker News front page yesterday with a discovery that surprised some developers: Claude Code's "extended thinking" output isn't the raw chain-of-thought reasoning. It's a summary.

The discussion quickly moved from "scandal" to "wait, this is documented" to "but what does it actually mean for my workflow?" The short version: Anthropic documents the behavior, but developers still need to know what is visible, what is billed, and what counts as an audit trail.

What McCanna Found

McCanna examined session logs stored on disk over a weekend and found only encrypted signatures (around 600 characters) with no readable text. Digging into Anthropic's documentation, he discovered that:

1. Claude encrypts its actual reasoning into signatures that Anthropic controls
2. Users' machines don't receive the decryption key
3. The API returns a summary of reasoning, not the reasoning itself
4. Full thinking output requires an enterprise agreement

His analogy: "This is like saving a jpeg as a .bmp and then editing the .bmp and presenting it as a jpeg. The conversion produces data loss."

(A few HN commenters pointed out he got the lossy format backwards - JPEG is the lossy one, BMP is lossless - but the point stands.)

What HN Is Saying

The discussion breaks into several threads:

"This Isn't News"

The most common response: this is documented behavior, not a hidden secret. Commenters also pointed out that major AI labs generally avoid exposing raw reasoning because it can reveal too much about model behavior and can be used for distillation.

The useful takeaway is not "Anthropic hid this." It is "visible thinking text is a developer interface, not a forensic transcript."

The Anti-Distillation Argument

Several commenters explained why AI labs hide raw thinking tokens: competitors can train on exposed chain-of-thought to replicate results.

There's even an open acknowledgment that this already happens with whatever output is available - someone shared a Hugging Face model fine-tuned on Opus "thinking" tokens.

The Practical Impact

For working developers, the key question is: does this matter for your workflow?

A critical detail from the docs and discussion: the readable summary is for human consumption. The underlying thinking blocks are represented by opaque signatures when passed back to the API.

And crucially: you're billed for the full thinking tokens, not the summary.

The Workaround

If you want more explicit reasoning text without encrypted summaries, you can go old-school and ask the model to reason in ordinary output:

Example prompt structure:

Before providing your answer, think step by step. For example:

The user is asking me to...
I need to think about the blah blah. First, I should foo the bar, and then...

Answer: <put your final answer here>

This bypasses the summarization entirely - but you lose whatever optimization Anthropic has built into their thinking mode.

The Philosophy Question

Some comments went deeper on what "authentic thinking" even means for an LLM.

Research has shown that the text a model produces in its "reasoning" may not accurately reflect the actual activation patterns happening internally. So even "raw" thinking tokens might not be the ground truth.

What Changed in the Current Docs

Anthropic's current docs make three practical points worth separating:

• The Messages API can return a summary of the full thinking process.
• The encrypted signature field is opaque and should not be parsed.
• You are billed for the full generated thinking tokens, not just the visible summary.

The newer model defaults also matter. Some models default to visible summaries, while newer models can default to display: "omitted", where the visible thinking field is empty and only the signature remains. Separately, Anthropic now recommends adaptive thinking and effort controls for newer models rather than old manual budget_tokens patterns.

For teams watching spend, this connects directly to Claude Code usage limits, Claude token burn observability, and what a fleet of Claude agents actually costs. Visible text is not the cost surface. Token accounting is.

The Encryption Angle

Matthew Green's cryptography writeup adds a separate lesson: encrypted reasoning blobs are not just hidden text. They are active protocol objects that can affect later model behavior when replayed. His experiments around replay and side channels are a reminder that "encrypted" does not mean "irrelevant to application security."

For application builders, the conservative rule is simple: do not parse, modify, log, or treat thinking signatures as user-readable audit evidence. Treat them as provider-controlled protocol state. If your product needs an audit trail, record prompts, tool calls, approvals, files changed, diffs, and final answers. Do not promise an audit trail of the model's private reasoning.

What This Means for Your Workflow

If you're debugging agent behavior: The summary should be sufficient for most prompt engineering. You see the key decision points. But if you need to trace exactly why a model made a specific choice, you're working with compressed information.

If you're measuring performance drift: McCanna's original concern was tracking changes over time. With summarized output, you're comparing summaries - which may vary even if the underlying reasoning stays consistent.

If you're worried about costs: You're already paying for the full reasoning. The summary is a presentation convenience, not a cost reduction.

If you care about distillation protection: This matters more for AI labs than individual developers. But it does mean you can't easily capture and reuse Claude's exact reasoning patterns for your own fine-tuning.

If you need reviewable agent work: Shift attention away from hidden reasoning and toward receipts: tool calls, diffs, tests, logs, permissions, and human approvals. This is the same discipline behind long-running agent harnesses, agent swarms needing receipts, and Claude Code agent teams.

The Bigger Picture

This situation reveals a tension in the AI tooling space: developers want transparency for debugging and understanding, but AI labs have commercial reasons to obscure how their models work.

Anthropic's approach is documented and defensible - you get enough to debug, they protect enough to prevent easy replication. Whether that tradeoff works for you depends on your use case.

For most Claude Code users, the summary is fine. For researchers trying to understand model behavior at a deep level, you'll need to look elsewhere - or pay for enterprise access.

FAQ

Is Claude Code showing raw chain-of-thought?

No. The visible extended-thinking text should be treated as a summary or display layer, not the raw reasoning transcript.

Are you billed for the summary or the full thinking?

Anthropic's docs say billing is based on the full thinking tokens generated internally. The visible summary can be much shorter than the billed output token count.

Can I use visible thinking as an audit log?

Not safely. Use it for debugging and prompt iteration, but build audit trails around prompts, tool calls, files touched, diffs, approvals, and final outputs.

Can I force the model to show detailed reasoning?

You can ask for step-by-step reasoning as ordinary output, but that is different from native extended thinking. It may help debugging, but it loses whatever behavior Anthropic attaches to native thinking mode.

Sources

• Original Blog Post - Patrick McCanna
• Hacker News Discussion
• Anthropic Extended Thinking Docs
• Anthropic Adaptive Thinking Docs
• Anthropic Pricing Docs
• Claude Extended Thinking Announcement
• Matthew Green: Fooling around with encrypted reasoning blobs