On July 20, 2026, Anthropic effectively told Claude Code users to stop reaching for the effort dial first. According to a report from Quasa.io, the company has drawn a sharp line between model capability and task effort — two controls that users often confuse. The core message: if the AI reads your code, uses available tools, and still can’t deliver, you need a smarter model, not more effort. Conversely, if it skips steps or bails early, raising effort may push it to be more thorough. For the 80% of work where defaults already work, Anthropic’s advice is blunt: leave the settings alone.

The Two Controls: Capability vs. Persistence

Claude Code gives users two levers: model selection and effort level. They look similar in the settings panel, but they operate on fundamentally different layers of the assistant’s behavior.

A model is a frozen set of weights — it’s what Claude “knows” about TypeScript patterns, PowerShell quirks, or common security vulnerabilities. Switching from Sonnet to Opus trades up for stronger reasoning and a larger knowledge base, but it also costs more per token. Effort, on the other hand, is a behavioral signal trained directly into the model. It dictates how many files Claude reads, whether it runs tests, how far it pushes through multi-step refactors, and how much verification it performs before reporting back. At high effort, the same task can consume roughly seven times more tokens as Claude double-checks its work.

Anthropic’s system cards and documentation stress that effort is not a second-class hack — it’s part of the model’s learned policy, passed as an additional input token. However, it does not change the model’s underlying intelligence. “A model is simply a fixed set of weights trained once,” the Quasa.io report states, summarizing Anthropic’s stance. “Everything Claude ‘knows’ lives in those weights. Your prompt, CLAUDE.md file, conversation history, and open files are all just context — they steer the model for that one request but don’t teach it anything new.”

This distinction is the foundation of the new official diagnostic.

A Tale of Two Failures: The Diagnostic Heuristic

When Claude Code falls short, the fix depends on the type of failure. Anthropic’s guidance, now crystallized in the Quasa.io piece and its product docs, breaks it into a simple if-then:

  • If Claude read the relevant files, used available tools, and still could not solve the problem → capability issue. Switch to a larger model (e.g., from Sonnet to Opus).
  • If Claude skipped files, ignored tests, abandoned a refactor halfway, or failed to verify its work → effort issue. Raise the effort level.

This heuristic should be applied after you’ve fixed the obvious context problems: a vague prompt, missing CLAUDE.md, or insufficient tool access. “The best lever is usually better context and clearer instructions, not another twist of the dials,” the original Quasa.io report emphasizes.

To help users recognize the difference, consider these practical signs:

Signs of a capability ceiling
- Claude repeatedly misinterprets a complex architectural pattern despite reading every related module.
- It proposes a solution that is syntactically correct but logically flawed for the domain.
- It consistently fails at a task that requires deep framework-specific knowledge (e.g., advanced WPF data binding or COM interop).

Signs of insufficient effort
- Claude only examines the top-level file in a multi-module project and suggests a patch that breaks other modules.
- It writes code but never runs the test suite, leaving broken tests behind.
- It begins a three-step refactor, completes step one, and stops without linking the remaining steps.

This framework puts model choice and effort on equal footing as separate, intentional controls rather than interchangeable knobs.

What This Means for Your Workflow

Depending on how you use Claude Code, the practical impact varies.

For Everyday Windows Users

If you’re a hobbyist or a student using Claude Code to build a personal website, automate a simple PowerShell script, or tinker with Python, you likely never need to touch effort or switch models. Stick with the default Sonnet model at high effort. Your time is better spent writing a clear CLAUDE.md that describes your project conventions and environment. Crank up effort only if you notice Claude repeatedly handing in half-finished work, and never before confirming your prompt is unambiguous.

For Power Users and Developers

Windows developers working on large .NET solutions, PowerShell modules, deployment scripts, or Azure Resource Manager templates stand to gain the most from the diagnostic. Picture this scenario: you feed Claude a 5,000-line PowerShell script that manages Active Directory users, and it reads every function but still can’t fix a subtle race condition in the logging code. That’s a capability limit. Bumping effort from high to xhigh will only burn tokens re-reading the same logic; switching to Opus 4.7 brings a deeper reasoning engine that can trace concurrency edge cases.

Counter-intuitively, on tough multi-file work, Opus on low effort can be cheaper overall than Sonnet on high effort. A larger model may reach a working solution in two iterations, while a smaller model thrashes through five failed attempts, each consuming tokens. “A more capable model can sometimes be cheaper for a complex job if it reaches a correct solution in fewer failed iterations,” Anthropic notes. For routine refactors, however, the bigger model is just burning money.

For IT Administrators

When using Claude Code for configuration management, infrastructure-as-code (DSC, Ansible playbooks), or security audits, the “context first” rule is paramount. Ensure Claude has access to your test environment, linting tools, and a CLAUDE.md that spells out compliance rules. If a task involves complex dependencies across multiple services, start with Opus — it’s more likely to detect cross-cutting concerns without being told. Save effort tuning for tasks where you want exhaustive verification, like parsing entire Group Policy Objects for consistency.

The Backstory: How Anthropic Learned This Lesson

Claude Code’s effort setting wasn’t always so well-understood. In March 2026, Anthropic quietly lowered the default reasoning effort from high to medium in response to user complaints about long latencies. The result, detailed in an April 23 postmortem on the company’s blog, was immediate backlash: users reported that Claude felt “less capable,” even though the underlying model hadn’t changed. Anthropic reverted the change on April 7.

“That episode crystallized what Anthropic had suspected: users equate effort with intelligence, even though that’s not technically accurate,” the Quasa.io analysis explains. “The company realized it needed to clearly separate the two controls in its public guidance.”

Today, the defaults are: Opus 4.7 at xhigh effort, and all other models (Sonnet, Fable) at high. Anthropic says these settings reflect its preferred balance of quality, latency, and usage limits — not a recommendation that users constantly tune effort per prompt. Its newer model cards repeat the same economics: higher effort is for genuinely difficult, long-running tasks, not for everyday chores.

What to Do Right Now

Stop twisting knobs and follow this five-step checklist:

  1. Fix context first. Create or update your CLAUDE.md with project conventions, test commands, and acceptance criteria. Grant access to build tools and linters. A messy prompt wastes more tokens than any wrong effort setting.
  2. Use the defaults. Let Opus 4.7 run at xhigh only if you’re certain the task demands frontier reasoning. For everything else, Sonnet on high effort is the safe, economical choice.
  3. Diagnose the failure. When a result is poor, ask: did Claude read and attempt the work honestly? If yes, upgrade the model. If it cut corners, raise effort.
  4. Consider the economics. If a task requires several back-and-forths, try a larger model on low effort. Track the total token consumption, not the per-turn cost. An Opus one-shot can be cheaper than five Sonnet retries.
  5. Set effort as a workflow preference, not a per-task tweak. If you always work on deep, multi-file refactors, default to high effort. If you mostly need quick ad-hoc scripts, medium may suffice. Avoid the temptation to fiddle with the slider for every prompt.

Outlook

Anthropic will almost certainly continue calibrating default effort levels as it collects real-world telemetry. The next frontier may be adaptive effort — where Claude automatically dials its thoroughness based on the complexity it detects — but until then, the two separate controls will remain. Developers who internalize the difference now will save tokens, time, and frustration. Watch for updates to Claude Code’s settings panel and any announcements around the Fable model tier, which promises narrow-specialist capability on obscure domains at low effort. For now, the rule is simple: if it’s a brain problem, change the model; if it’s a diligence problem, change the effort; and if you haven’t written a good CLAUDE.md, change that first.