The entire internet is complaining that Claude has gotten dumber, and Anthropic steps in to reveal: it's not the model that's letting you down

Does switching to a larger model equal greater intelligence?

[Introduction] Does switching to a larger model mean greater intelligence? This is probably the most common misconception among Claude Code users. Many people keep upgrading all the way to the most expensive Fable model for this very reason, but recently, Anthropic personally clarified this misunderstanding.

Have you ever had this moment: when Claude Code messes up writing code, your first reaction is immediately switching to a more powerful model.

But this trick often does not work, and even wastes your money for nothing.

Recently, the official Anthropic team published a long article specifically addressing this issue.

Official long article from Anthropic

The root cause is that too many users confuse two options in Claude Code:

One is Model selection, and the other is Effort level.

Official long article from Anthropic

In the past, people's understanding of these two options was very simple: switching to a larger model makes the AI smarter; raising the Effort level simply lets the AI think for a little longer.

However, this misunderstanding even caused quite a stir back in March this year.

At that time, many developers found that their Claude Code suddenly "got dumber": it failed to read the required files, skipped scheduled tests, abandoned tasks halfway, and instead asked users for more information.

As a result, there was a flood of complaints on GitHub.

The most pointed criticism came from Stella Laurenzo, the head of AI at AMD.

She pulled logs from 6852 sessions on GitHub and ran actual tests, finding that Claude's thinking volume had dropped by 67% compared to before February, and she stated bluntly:

Claude can no longer be trusted to handle complex engineering work.

Claude can no longer be trusted

At first, people thought they had written bad prompts or made some wrong configuration. After struggling for a long time, they finally realized: the problem was not on their end at all, Anthropic had quietly changed a setting.

On March 4, in order to reduce latency, they lowered the default Effort level in Claude Code from high to medium.

The change was noted in the official update log, but most users did not notice it, they only felt that the model in their hands had inexplicably become less capable.

After bearing the backlash for a month, Anthropic finally restored the default level on April 7, and reset the usage quota for all subscription users.

It was then that most users realized this switch had been right beside them all along, secretly determining whether the AI would devote its full capacity to work for them.

Model determines the capability, Effort determines the dedication

Anthropic's official breakdown can be summed up in one simple sentence:

Model determines the capability, Effort determines the dedication.

First, the Model defines the underlying capability.

Each model is backed by a set of "frozen weights", whose capabilities and knowledge are permanently fixed the moment training is completed: read-only and unmodifiable.

This means that the prompts you feed in during inference, the CLAUDE.md file, and the code you paste into the context cannot alter this set of weights at all: you can guide it, but you cannot "train" it.

Switching models essentially means replacing the entire set of weights to take over your task, so it solves the problem of "whether the AI is capable of doing it".

For a library that did not even exist when the model was trained, even if you feed it the full documentation, it can learn and use it on the fly, but this only works for that single request. The model itself does not retain any information, and forgets everything immediately afterward.

The same logic applies when it occasionally seriously calls a non-existent API: it is not a case of missing information, but the weights are following old patterns from training to piece together a random sequence.

Looking deeper at the underlying mechanism makes it even clearer. The code you write, such as `const x = await fetch`, is first split into individual tokens from the model's perspective, each mapped to a number in the vocabulary.

Image source: Official Anthropic blog post

A single line of code you write, after being split into tokens, corresponds to an integer in the vocabulary: `const` is 1078, `await` is 2597, and the total vocabulary size is around 100,000. What the model receives is never plain text, but this sequence of numbers.

The model does not output the entire response in one go. It predicts only one token at a time, appends it to the sequence, then recalculates the entire sequence to predict the next token. A 200-token response requires 200 full computation cycles.

The majority of your waiting time and token costs are consumed in this loop.

Next, the Effort level determines the "dedication" the AI puts into the task.

Many people mistakenly believe that a high Effort level simply means "thinking for a few more seconds".

What it actually controls is how much workload Claude devotes to this specific task: how many files it reads, whether it runs tests, if it performs extra verification, and whether it pushes a multi-step task all the way to completion before coming back to you.

To put it plainly: Claude at low Effort tends to respond quickly, then asks you for more context, avoiding hands-on work whenever possible; Claude at high Effort tends to look up information on its own, call tools multiple times, and complete the entire long task chain in one go.

The Effort setting in Claude Code has multiple levels, and you should not treat it as a rigid token budget limit.

It is a behavioral signal that tells Claude how thoroughly and confidently the task needs to be completed, governing text responses, tool calls, and extended thinking all at once.

The official team also released an illustration: for the exact same prompt, Claude at high Effort can generate roughly 7 times more tokens than at low Effort. All those extra tokens are spent reading files, running verifications, and double-checking results.

Image source: Official Anthropic blog post

For the same prompt, the high-Effort path generates approximately 7 times more tokens than the low-Effort path, with all extra tokens spent on reading files, running verifications, and repeated confirmation.

This reveals a counterintuitive conclusion: a small model running at high Effort can absolutely outperform a large model running at low Effort.

Not incapable, just not putting in enough effort

Once you understand the division of responsibilities between Model and Effort, the official judgment framework becomes extremely useful.

Image source: Official Anthropic blog post

Official judgment framework: When Claude makes a mistake, first determine whether it is not smart enough or not putting in enough effort, then decide whether to switch models or increase the Effort level.

When Claude messes up a task, do not rush to change the model selection.

The first step is always to check the context: is the prompt clear? Are all required tools provided? Is the CLAUDE.md file configured correctly? Most so-called "AI getting dumber" issues are rooted here, not in the model selection.

If the context is indeed correct but the AI still makes mistakes, ask yourself: is it incapable of doing the task, or is it just not trying hard enough?

"Not trying hard enough" is easy to identify: it skips files that should be read, fails to run tests, and abandons a refactoring task halfway to ask you for help. What it lacks is not underlying capability, but sufficient dedication.

This is an Effort-related issue, and you can raise the Effort level by one notch.

If it is genuinely "incapable", that is a different scenario: you have provided full context, it clearly tried its best, but still makes mistakes, and even rephrasing the prompt multiple times cannot fix the problem.

In this case, no amount of increased Effort will help, the issue lies with the model itself: you need to switch to a more powerful model.

The official team also gave a very easy-to-understand analogy.

Sonnet is a versatile all-rounder who has an entire afternoon available to work.

It will read your code from start to finish, run it once, verify it again, and truly fully understand your codebase.

Opus is an expert who only gives you 5 minutes. It brings experience that does not exist at all in your codebase, with insights into common pitfalls and workarounds accumulated from solving a large number of similar problems. But with only 5 minutes, it can only glance at your code, and cannot read through every single file.

Fable is a specialist that you can only invite when everyone else is stuck. Even with only 5 minutes, it can instantly spot the bug that no one else could find.

Of course, this specialist also costs the most per token, so you should reserve it only for the truly tough tasks that no one else can handle.

This is where that counterintuitive conclusion comes from:

A Sonnet running at high Effort can genuinely outperform an Opus running at low Effort on many tasks. A small model paired with sufficient context and high dedication can handle far more work than you would expect.

Image source: Official Anthropic blog post

On long, multi-step tasks, Fable has the largest performance gap. In official tests, some tasks cannot be completed by Opus and Sonnet even at their maximum Effort levels.

After chasing model rankings, task assignment for AI has become a critical skill

This official explanation, on the surface, teaches you how to tune parameters, but behind it lies an important shift:

The competition in AI programming is shifting from "who has a more powerful model" to "who is better at orchestrating AI agents".

In the past, things were simple: users picked the most powerful model, and left everything else to it.

Now it is different. You need to act like a project manager, assigning different roles and different dedication levels to different models:

Assign simple modifications to Sonnet at low Effort, for instant responses and low cost; use a more powerful model at high Effort for large-scale refactoring; for long-running agent tasks, pair a strong model with sufficient Effort.

These operations not only make the work better, but also save you a lot of money on token bills.

The newly added "ultracode" option in Claude Code's Effort menu brings this "orchestration" mechanism directly into the product.

When selected, Claude gets the xhigh Effort level, plus an authorization: when facing substantial work, it can decide on its own whether to spin up a team of AI agents, split the task, and run it in parallel.

Looking back at the "getting dumber" incident in March.

It was able to stir up the entire community precisely because most users were still stuck in the old mindset of "just switch models", completely unaware of the far more critical Effort setting right at their fingertips.

The era of only looking at model rankings is passing, and orchestrating models is becoming a core skill.

Whoever learns to assign tasks to AI first will get a head start, using a Claude that truly goes all out for them. Otherwise, no matter how expensive the model you have, it will only be a more costly search box.

In this way, every token you spend is truly put to good use.

References:

https://claude.com/blog/claude-model-and-effort-level-in-claude-code

https://x.com/ClaudeDevs/status/2074900291062034618?s=20

https://platform.claude.com/docs/en/managed-agents/multi-agent

Edited by: Yuan Yu

This article is from the WeChat public account "Xin Zhi Yuan", written by ASI Revelation, and published by 36Kr with authorization.