Claude Code Got 67% Dumber. AMD's AI Director Had the Data to Prove It.

You're running Claude Code on a production codebase. It used to read six or seven files before making an edit. It used to think through problems step by step, catching edge cases before they became bugs. It used to be careful.

Then one morning in March 2026, it stopped. It started rewriting entire files instead of making targeted edits. It stopped reading related files before changing code. It started guessing instead of checking. And the bugs started piling up.

You weren't imagining it. And you're not alone. Stella Laurenzo, director of AMD's AI group, had the telemetry data to prove exactly what happened, when it happened, and how bad it got. She filed GitHub issue #5365 with the receipts. The title said it plainly: "Claude-Code is getting dumber."

The Dataset That Ended the Debate

Most complaints about AI tools getting worse are vibes. Someone notices their outputs feel lazier and posts about it on Twitter. Anthropic says they haven't changed anything. The cycle repeats.

Stella Laurenzo broke that cycle with something the AI industry rarely sees: actual data at scale.

She analyzed 6,852 Claude Code sessions, covering 234,760 tool calls and 17,871 thinking blocks. This wasn't a weekend sample. This was months of production usage from a professional engineering team at AMD, one of the largest chip companies on the planet.

The findings were damning. Here's what the data showed:

Let those numbers sit for a second. The model went from reading 6.6 files on average before making an edit to reading just 2. That's not a minor regression. That's the difference between a senior developer who checks the codebase before changing something and a junior developer who edits the first file they find and hopes for the best.

What Anthropic Actually Changed (And Admitted To)

After the issue gained traction, Anthropic confirmed two specific changes that lined up with the performance cliff.

Change one: "Adaptive thinking" (February 9). Anthropic introduced a system that dynamically adjusts how much the model reasons before responding. The idea was efficiency. If a task seems simple, the model spends less time thinking about it. In practice, the model started treating complex tasks as simple ones and skipping the reasoning that made it useful.

Change two: Default thinking budget flipped from "high" to "medium" (March 3). This is the one that broke things for most users. Claude Code's default thinking budget was quietly changed from high to medium. Users who hadn't explicitly set their thinking budget to high got a model that was spending roughly half the mental energy on every task.

The timing lines up perfectly with Laurenzo's data. The laziness indicators that had been at zero for months started appearing immediately after March 8, when the combined effect of both changes was fully rolled out.

The model didn't get dumber. It was told to think less. The result looked the same to users, but the cause was a configuration decision, not a capability regression.

This distinction matters. Claude's underlying capability didn't shrink. Anthropic chose to reduce the default amount of reasoning the model does per task. For simple tasks, this might be fine. For the kind of complex, multi-file engineering work that teams like AMD's do, it was a disaster.

The File-Reading Problem Is Worse Than It Sounds

The headline number, 67% drop in thinking depth, gets the attention. But the file-reading collapse is the one that actually breaks codebases.

When Claude Code reads 6.6 files before making an edit, it understands the context. It knows what functions depend on the file it's changing. It sees the test files. It checks the imports. It reads the configuration. Then it makes a targeted edit that fits into the existing structure.

When it reads 2 files before editing, it's flying blind. It doesn't know what depends on the file it's changing. It doesn't check the tests. It doesn't read related modules. So instead of making a surgical edit to the specific function that needs changing, it rewrites the entire file from scratch.

That's what Laurenzo's data showed. Claude Code shifted from targeted edits to full file rewrites as the default behavior. Full file rewrites are dangerous in any codebase because they:

• Overwrite changes other developers made that aren't related to the current task
• Break formatting, comments, and documentation that existed in the original file
• Introduce subtle bugs by reimplementing functions from memory instead of reading the actual code
• Make version control diffs unreadable, making code review nearly impossible

If you're a solo developer using Claude Code on a personal project, a full file rewrite is annoying. If you're an engineering team at AMD with hundreds of interdependent files, it's a production risk. And the data showed this was happening consistently, not occasionally.

We compared Claude Code's approach to other AI coding tools in our Claude Code vs Codex breakdown. The file-reading behavior is one of the key differentiators, and when it breaks, the advantage disappears.

CLAUDE.md Files Might Be Making It Worse

Here's an angle most people are missing. A widely circulated Medium article raised a question that lines up with Laurenzo's data: are CLAUDE.md files making AI agents dumber?

CLAUDE.md is the configuration file that tells Claude Code how to behave in a specific project. It contains rules, context, coding standards, file descriptions, and behavioral instructions. The idea is that more context helps the model make better decisions.

The problem is that more context also fills up the context window. And when the context window is packed with instructions, rules, and documentation, the model has less room to actually think about the task at hand. It's the AI equivalent of giving a new hire a 200-page employee handbook on day one and expecting them to memorize it before writing a single line of code.

Combined with the reduced thinking budget, bloated CLAUDE.md files create a compounding problem:

• The model has less room to reason (medium thinking budget instead of high)
• The context window is already half-full with configuration before the task even starts
• The model skips reading files because it's already processing thousands of tokens of instructions
• The result is shallow, lazy outputs that look like the model is getting dumber

The fix isn't to remove your CLAUDE.md file. It's to make it lean. Keep only the instructions that directly affect code quality. Remove anything the model doesn't need for every single task. Treat your CLAUDE.md like a system prompt, not a wiki page.

What This Means for Anyone Using AI Agents in Production

This isn't just a Claude Code story. It's a warning about every AI agent deployment.

The core issue is this: model providers can change how your agent behaves without telling you, and without changing the model itself. Anthropic didn't swap out Claude's brain. They adjusted a dial. But the downstream effect was a 67% reduction in reasoning quality for complex tasks.

If you're running AI agents for your business, whether that's customer support, lead qualification, content generation, or code assistance, you're exposed to the same risk. The model you tested and approved last month might behave differently today because the provider changed a default setting on their end.

This is why agent configuration and monitoring matter more than model selection. The best model in the world will underperform if it's configured wrong. And the configuration can change underneath you without warning.

Three things you should be doing right now:

• Set explicit thinking budgets. Don't rely on defaults. If your agent supports a thinking or reasoning parameter, set it to the highest level you can afford and lock it there.
• Monitor agent behavior over time. Track metrics like response quality, task completion rate, and (for coding agents) file reads before edits. If the numbers change, something changed upstream.
• Keep system prompts and configuration files lean. Every token of unnecessary context is a token the model can't use for reasoning. Cut ruthlessly.

The Bigger Picture: Trust and Transparency in AI Tooling

The most important part of this story isn't the 67% number. It's the fact that it took an AMD engineering director filing a public GitHub issue with telemetry data before Anthropic acknowledged the changes.

Most users don't have 6,852 sessions of telemetry data to analyze. They noticed Claude Code felt worse, posted about it, and were told nothing had changed. The "vibes vs data" asymmetry is the real problem. Users feel the degradation. Providers deny it. And without data, the user loses the argument every time.

Laurenzo's contribution wasn't just proving that Claude Code got lazier. It was proving that users need their own telemetry to hold AI providers accountable. If you're building on top of any AI model and you're not tracking your own performance metrics, you're trusting a company to never make a change that hurts your use case. That's not a reasonable assumption in 2026.

This is a pattern we've seen before. We wrote about how Claude's managed agents model changes the relationship between businesses and AI providers. The more you depend on a provider's defaults, the more exposed you are when those defaults change.

And for AI-powered business operations specifically, we covered the risks and opportunities in our piece on how to automate your business with AI bots. The configuration layer is where most setups succeed or fail.

How to Protect Your AI Agent Setup

Whether you're using Claude Code for engineering work or running AI agents for customer-facing business operations, here's the practical playbook based on what Laurenzo's data teaches us.

1. Never trust default settings. Set every parameter explicitly. Thinking budget, temperature, max tokens, tool permissions. Defaults are optimized for the provider's cost structure, not your output quality.

2. Build your own monitoring. Track at least three metrics: task completion rate, output quality (even a simple thumbs up/down), and behavioral consistency (is the agent doing the same steps it did last week?). You don't need AMD-level telemetry. A spreadsheet works.

3. Keep configuration files under 500 lines. If your CLAUDE.md or system prompt is longer than that, you're probably hurting performance. Audit it quarterly. Remove anything that doesn't directly improve output quality.

4. Test after every provider update. When Anthropic, OpenAI, or any provider announces a change, run your standard test suite immediately. Don't wait for users to report problems. By then the damage is done.

5. Have a fallback. If your primary AI agent degrades, you need to be able to switch models or revert configurations within hours, not weeks. Build your agent stack with portability in mind.

The teams that followed these practices didn't get burned by the March thinking budget change. The teams that trusted defaults lost weeks of engineering productivity before they figured out what happened.

The Bottom Line

Claude Code got measurably worse in March 2026. Not because the model lost capability, but because Anthropic reduced the default amount of thinking it does per task. An AMD engineering director proved it with 6,852 sessions of telemetry data that showed a 67% drop in thinking depth and a 70%+ drop in file-reading before edits.

The fix for Claude Code specifically is to set your thinking budget to high explicitly. The fix for AI agents broadly is to never trust defaults, monitor your own metrics, and keep your configuration files lean.

AI agents are powerful tools. But they're tools that can be silently downgraded by the people who host them. The only protection is your own data and your own configuration discipline.

If you're running AI agents for your business and you're not sure whether your configuration is solid, we do free audits. Fifteen minutes, no pitch, just a clear picture of where your setup stands and what to fix.

Frequently Asked Questions

Did Claude Code actually get dumber in 2026?

Yes, and there is hard data to back it up. Stella Laurenzo, director of AMD's AI group, analyzed 6,852 Claude Code sessions and found that thinking depth dropped 67%, file reads before edits dropped from 6.6 to 2 on average, and laziness indicators went from zero to 10 per day after Anthropic changed default thinking settings in early March 2026.

What caused Claude Code's performance to drop?

Anthropic confirmed two changes. First, an "adaptive thinking" update on February 9 that dynamically adjusts how much the model reasons. Second, a change on March 3 that flipped the default thinking budget from "high" to "medium." The combination reduced how carefully Claude Code reads files, plans edits, and reasons through problems before acting.

What is GitHub issue #5365 about?

GitHub issue #5365, titled "Claude-Code is getting dumber," was filed with detailed telemetry data showing measurable performance degradation in Claude Code. The data included analysis of 234,760 tool calls and 17,871 thinking blocks, proving that the model's reasoning depth and careful file-reading habits declined significantly after Anthropic's configuration changes.

Can CLAUDE.md files make AI agents perform worse?

There is growing evidence that poorly structured CLAUDE.md files can degrade agent performance. Overloading the context window with too many rules, contradictory instructions, or excessive documentation can cause the model to reason less carefully about the actual task. The quality and structure of your configuration files matters as much as the model itself.

How do you prevent AI coding agents from getting lazy?

Three things help. First, set the thinking budget to "high" explicitly rather than relying on defaults. Second, keep your CLAUDE.md and system instructions lean and well-structured. Third, monitor your agent's actual behavior over time with telemetry. If you rely on AI agents for business operations, working with a team that tracks and adjusts these configurations is worth the investment.