Filed the original issue with rigorous before-and-after metrics showing the model's Read-to-Edit ratio dropped from 6.6 to 2.0 — a 70% reduction in research before making changes. Their 50+ concurrent agent sessions saw costs spike from $345 to $42,121 monthly, with 80x more API requests and 170x more input tokens for the same number of user prompts.
Submitted the issue to Hacker News where it received 1,260 upvotes and 699 comments, indicating widespread recognition of the regression among the developer community. The volume of engagement suggests the problem resonated far beyond a single user's workflow.
The editorial argues the behavioral shift — edits without prior reads jumping from 6.2% to 33.7% — mirrors the difference between a careful engineer and someone who guesses without reading. This frames the regression not as a simple bug but as a systemic change in how the model approaches complex multi-step tasks, where cost and quality are deeply coupled.
Notes that Anthropic closed the issue as COMPLETED, but highlights that the story lives in the gap between 'acknowledged' and 'fixed.' The editorial frames this as an accountability question — whether closing an issue constitutes a meaningful resolution for users who experienced a 122x cost spike.
Published a snapshot of Claude Code's source code explicitly labeled 'for research,' preserving the codebase at a point in time. This positions independent scrutiny as necessary when users depend on proprietary AI tools whose behavior can change without warning or user consent.
On GitHub issue #42796 in Anthropic's claude-code repository, a user named stellaraccident filed what may be the most meticulously documented AI quality regression report ever written. The issue — titled "Claude Code is unusable for complex engineering tasks with the Feb updates" — arrived with 122 comments, rigorous before-and-after metrics, and a damning conclusion: the same number of user prompts (roughly 5,700) consumed 80x more API requests and 170x more input tokens after the February model changes, driving monthly costs from $345 to $42,121.
The reporter wasn't a casual user. Their workflow involved 50+ concurrent Claude Code agent sessions doing systems programming — C, MLIR, GPU drivers — with autonomous runs lasting 30+ minutes. During the "good period" (late January through mid-February), this setup merged 191,000 lines across two PRs in a single weekend. After the regression hit, the same workflows became a costly exercise in babysitting.
Anthropics closed the issue as COMPLETED, acknowledging the problem. But the gap between "acknowledged" and "fixed" is where this story lives.
The regression metrics are unusually precise because the reporter tracked tool-call ratios across sessions. The most revealing metric: the Read-to-Edit ratio — how many times the model reads a file before modifying it.
| Period | Read:Edit Ratio | Research:Mutation Ratio | |--------|----------------|------------------------| | Good (Jan 30 – Feb 12) | 6.6 | 8.7 | | Degraded (Mar 8 – Mar 23) | 2.0 | 2.8 |
The model went from reading a file 6.6 times per edit to just twice — a 70% reduction in research before making changes. Any senior engineer recognizes this pattern: it's the difference between a careful contributor and someone who opens a file, makes a guess, and hopes `git diff` looks right.
The behavioral consequences cascaded predictably:
- Edits without prior read: 6.2% → 33.7% (+443%) - Stop hook violations: 0 total → 173 in 17 days (peaking at one every 20 minutes) - Reasoning loops per 1K calls: 8.2 → 21.0 (+156%) - "Simplest fix" language frequency: +642% - User interrupts: 12x increase in manual corrections
That last metric — "simplest fix" appearing 642% more often — captures something qualitative that developers have been complaining about across forums: the model increasingly proposes shallow patches instead of understanding the problem. It's the AI equivalent of a junior dev who submits `// TODO: fix later` and calls it done.
The most controversial finding in the report correlates the regression with thinking token redaction. The reporter tracked a metadata field (`redact-thinking-2026-02-12`) that indicates whether the model's chain-of-thought reasoning was being compressed or hidden:
| Period | Thinking Visible | Thinking Redacted | |--------|-----------------|-------------------| | Jan 30 – Mar 4 | 100% | 0% | | Mar 8 | 41.6% | 58.4% | | Mar 12+ | 0% | 100% |
By mid-March, 100% of thinking content was redacted, correlating with an estimated 67-73% reduction in reasoning depth. The time-of-day analysis adds texture: thinking quality was worst at 5pm PST (423 chars median) and best late at night (up to 3,281 chars) — an 8.8x variance range compared to 2.6x before redaction began.
This raises a fundamental question about the economics of reasoning models. If Anthropic reduced thinking tokens to manage inference costs — a reasonable business decision — the tradeoff landed squarely on the users running the most complex, highest-value workloads. The power users subsidizing the platform through heavy API usage are precisely the ones most damaged by shallower reasoning.
A parallel signal reinforces the community's frustration. The repository `instructkr/claude-code` — a snapshot of Claude Code's source code published "for research" — has accumulated significant attention (score: 176,835 in our signals). The existence of a widely-starred research mirror of Claude Code's internals signals that developers don't just want to use these tools — they want to understand and verify what's happening inside them.
This isn't idle curiosity. When your tool silently changes behavior and your costs spike 122x, the ability to inspect the client-side code becomes a debugging necessity. The reporter's recommendations reflect this:
1. Expose thinking token metrics — let users see how much reasoning the model actually performed 2. Offer a "max thinking" pricing tier — guaranteed deep reasoning for users willing to pay 3. Include thinking token counts in API responses — basic observability 4. Use power-user canary metrics — stop hook violation rates as early warning systems
These aren't radical demands. They're the same observability expectations developers have for any production dependency. You wouldn't tolerate a database that silently reduced query planning depth to save CPU.
If you're running Claude Code in production workflows — especially agentic loops with autonomous multi-file changes — the practical implications are immediate.
Monitor your tool-call ratios. The Read:Edit ratio is a cheap, effective proxy for reasoning quality. If your agent starts editing files it hasn't read, something has changed upstream. Build this into your observability. It takes one log aggregation query.
Budget for variance. A 122x cost spike from the same workload is not a billing anomaly — it's what happens when a reasoning model starts thrashing. If you're running Claude Code against production codebases, your cost controls need circuit breakers, not just budget alerts. Cap API requests per session. Kill runs that exceed your Read:Edit baseline by more than 2x.
Pin your expectations, not just your versions. Model providers update weights continuously. Unlike library dependencies, you can't pin a model version (yet). What you can do is maintain a regression test suite — a set of known-good prompts with expected behavioral characteristics. When your test suite starts showing more edits-without-reads or reasoning loops, you know the model changed before your bill tells you.
Evaluate the competitive landscape. This regression coincides with a period where Cursor, Windsurf, and other AI coding tools are iterating rapidly. If your workflow depends on deep, autonomous reasoning over large codebases, benchmark alternatives quarterly. Loyalty to a tool that silently degrades is an engineering risk.
The meta-irony wasn't lost on the community: the most detailed analysis of Claude's regression was generated by Claude itself, analyzing its own session logs. That's either a testament to the model's capability when it works or a poignant reminder of what was lost. Anthropic closed the issue as completed, suggesting fixes are in progress or deployed. But the deeper tension remains unresolved — when AI coding tools become production infrastructure, they inherit production expectations: SLAs, changelogs, regression tests, and the basic courtesy of telling users when you've changed the engine while they're driving.
Claude Code Snapshot for Research. All original source code is the property of Anthropic.
→ read on GitHubTop 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.