Anthropic Admits It Broke Claude

A wave of developer complaints recently flooded social media platforms like X and Reddit, detailing a stark decline in Claude's coding capabilities. Programmers relying on the AI assistant reported a noticeable drop in its output quality, sparking widespread frustration. Many described Claude as suddenly "dumber," struggling with tasks it previously handled with ease.

This phenomenon isn't new; users often perceive a degradation, or AI 'nerfing,' in model performance long before official acknowledgments. Developers, intimately familiar with Claude's intricacies, immediately sensed a shift. Their anecdotal evidence painted a consistent picture of a once-reliable tool becoming forgetful and repetitive, especially during complex coding sessions.

That collective unease transformed into validation when Anthropic finally published a postmortem, confirming the widespread suspicions. The developer community's frustration gave way to a sense of "we told you so," as the company admitted to specific changes impacting Claude's performance. This transparency, albeit delayed, provided crucial insights into the underlying issues.

Anthropic's explanation detailed three core reasons for the degradation in Claude Code: - A reduction in default reasoning effort from "high" to "medium" aimed to decrease latency, inadvertently sacrificing capability on harder coding tasks. - A critical bug caused Claude to drop its prior reasoning after every idle session, making it appear forgetful and repetitive. - A modified system prompt, intended to reduce verbosity, significantly impacted code quality, forcing Anthropic to revert the change.

Crucially, the performance issues stemmed from the "harness" – the specific implementation known as Claude Code – rather than the core Claude model itself. This distinction highlights the fragility of the entire AI pipeline, where seemingly minor adjustments can have profound effects. Critics quickly questioned Anthropic's testing protocols, deeming it "insane" to deploy such impactful changes without thorough pre-release validation.

Anthropic then published 'An update on recent Claude Code quality reports,' offering an unprecedented level of candor. This blog post directly addressed the growing chorus of developer complaints, detailing the precise technical missteps that actually degraded Claude Code's performance. The company’s public admission stood out as a remarkable case study in corporate transparency within the often-opaque AI industry, setting a new benchmark for accountability.

The postmortem meticulously detailed three core reasons behind the observed decline in coding capability: - Anthropic confessed to altering the default reasoning effort for Claude Code from "high" to "medium." This change, implemented to reduce latency and make the model faster, inadvertently compromised its effectiveness on more complex programming tasks requiring deeper analytical thought. - A critical bug emerged, causing Claude to drop its old reasoning after every idle session. This fundamental flaw made the model appear forgetful and repetitive, severely impacting multi-turn coding dialogues where context retention is paramount. - A system prompt modification, initially intended to reduce verbosity and streamline outputs, unexpectedly degraded code quality so severely that Anthropic had to swiftly revert the change, acknowledging its detrimental impact.

AI community members and tech media reacted with a potent mix of surprise, criticism, and grudging respect. While some, like the Better Stack creator, expressed shock that such changes weren't adequately tested before deployment, many praised Anthropic's radical transparency. This directness offered a stark contrast to how other tech giants typically manage similar performance degradation issues with their flagship products.

Most companies, particularly in the competitive AI space, often resort to vague statements, attribute problems to "evolving usage patterns," or remain entirely silent, leaving users to speculate and frustration to fester. Anthropic's decision to lay bare its internal missteps, however, built significant trust. It validated developer frustrations rather than dismissing them, acknowledging the tangible impact on their workflows. This level of openness sets a new, higher bar for honesty and accountability in the rapidly evolving landscape of AI model development and deployment.

Anthropic's first acknowledged misstep involved a critical backend adjustment within Claude Code. Engineers altered the model's default reasoning effort, downgrading it from 'high' to 'medium'. This change directly dictated the computational resources and internal processing cycles Claude dedicated to each user query, effectively reducing its analytical depth.

Transitioning to 'medium' reasoning meant Claude performed fewer internal iterations and less complex problem decomposition. While the explicit goal was to decrease latency and accelerate response times, this pursuit of speed inadvertently sacrificed the model's meticulousness. Developers observed a marked decline in the quality and accuracy of generated code, particularly in scenarios demanding intricate logical thought.

This operational shift exemplifies a classic engineering trade-off between speed and performance, a dilemma uniquely challenging for large language models. Unlike

Anthropic’s postmortem revealed a second critical blunder: the "Amnesia Bug," a severe flaw plaguing Claude Code. This insidious defect caused the AI to completely discard its previous reasoning and conversational context after any period of user inactivity. Every time a developer paused their interaction – even briefly – Claude Code would reset its short-term memory, effectively "forgetting" everything discussed and forcing a fresh start.

This memory lapse proved devastating for developer productivity and workflow continuity. Imagine a programmer working with Claude Code to debug an intricate, multi-file issue, providing extensive context and architectural details.

After a brief interruption—perhaps to run a test suite or consult documentation—the AI would return devoid of any recollection. It frequently demanded re-explanation of the problem, reiterated solutions already rejected, and generated code ignoring hours of prior instruction, leading to immense frustration and wasted effort.

The core utility of any advanced AI assistant hinges critically on its ability to maintain conversation context and a persistent memory. Without this continuous thread of understanding, an AI cannot build incrementally on previous interactions or offer coherent, evolving solutions to complex problems. Claude Code's inability to retain its "old reasoning" after an idle period fundamentally undermined its collaborative potential, transforming it into a frustrating, stateless chatbot.

Anthropic’s third misstep involved a seemingly innocuous change to Claude Code’s system prompt. Developers modified the prompt with the explicit goal of reducing the model's verbosity, hoping to elicit more concise and direct code outputs. This adjustment aimed to streamline interactions and deliver answers without unnecessary conversational fluff.

However, this small tweak created a massive, unintended ripple effect, a classic example of the butterfly effect in prompt engineering. A slight alteration to the initial instructions drastically altered the model's interpretative framework, leading to a significant degradation in the quality and correctness of the generated code. The model, now constrained by the new prompt, struggled with complex logical structures and nuanced coding tasks it previously handled with ease.

The impact on code quality became so severe that Anthropic had no choice but to revert the system prompt to its original state. This rapid rollback underscores the extreme fragility of advanced, fine-tuned AI systems. Even minor adjustments to foundational instructions can destabilize performance, revealing the intricate dependencies within these complex neural networks.

Anthropic’s experience highlights the delicate balance required in prompt engineering. Developers cannot simply assume small changes will yield predictable outcomes; instead, meticulous testing and validation are crucial to prevent unforeseen regressions. This incident serves as a stark reminder of how easily the carefully calibrated performance of an AI model can unravel.

Anthropic's postmortem revealed a critical nuance: the problem did not originate with the core Claude foundation model itself. Developers experienced degradation in Claude Code, a distinct application built atop the underlying AI. This distinction is paramount for understanding the actual source of the recent performance issues.

A "harness" in the realm of large language models represents the sophisticated layer that optimizes a foundational model for a specific task. It encompasses a carefully curated combination of components designed to guide the model's behavior and output. These elements are crucial for tailoring an LLM's general capabilities to specialized domains.

Key components of a harness include refined system prompts, which steer the model's persona and instructions, and retrieval mechanisms for accessing external information. Configurations, such as the default 'reasoning effort' level, also fall under the harness's purview. The three mistakes Anthropic admitted — the reasoning effort change, the amnesia bug, and the altered system prompt — were all modifications to this Claude Code harness, not the base model.

Consider the relationship like a high-performance race car. The powerful engine represents the core Claude foundation model, inherently capable and robust. The harness, then, is the specific transmission, suspension tuning, and aerodynamic setup meticulously configured for a particular race track and driving style. A poorly tuned transmission or incorrect suspension settings will severely hinder the car's performance, even if the engine remains flawless.

Anthropic's missteps were akin to adjusting the car's tuning without proper testing, leading directly to the observed decline in coding quality. The underlying Claude engine remained unchanged, but its operational parameters within the Claude Code harness were compromised. For more details on how these configurations impact LLM performance, read how Mystery solved: Anthropic reveals changes to Claude's harnesses and operating instructions likely caused degradation | VentureBeat.

This incident underscores the complexity of deploying advanced AI. Even minor adjustments to an LLM's operational harness can dramatically alter its perceived intelligence and utility, highlighting the critical need for rigorous testing before broad deployment. The core model's capabilities were never in question; its specific application was.

Tech community outrage quickly followed Anthropic’s confession. Better Stack’s video, "Claude ACTUALLY got dumber...", highlighted the sentiment, with the creator expressing disbelief that Anthropic deployed such impactful changes without rigorous testing. "It’s kind of insane to me that they don’t test these things before pushing out these changes," the video stated, capturing widespread developer frustration.

This pointed criticism underscores a fundamental expectation among professionals: tools they rely on for their livelihoods demand stability. For developers integrating AI into complex systems, unexpected performance degradation from a critical API like Claude Code proves unacceptable. The immediate impact on productivity and project timelines becomes significant.

Silicon Valley’s long-held "move fast and break things" ethos faces increasing scrutiny when applied to foundational AI tools. While rapid iteration fuels innovation, shipping untested changes that compromise core functionality for professional users risks eroding trust. A model like Claude Code, designed for sophisticated programming tasks, requires a different standard of deployment.

Anthropic's admitted missteps — changing the default reasoning effort from 'high' to 'medium', introducing a memory-wiping bug after idle sessions, and altering the system prompt to reduce verbosity — represent significant modifications. Each change, if adequately tested, should have flagged the resulting performance degradation before public release. The issues were with the "harness," Claude Code, not the core model, but the user experience remained broken.

Developing effective regression tests for generative AI, however, presents unique challenges. Unlike traditional software where outputs are largely deterministic, AI models produce varied, non-exact responses. Automated evaluation metrics often struggle to capture nuanced quality shifts in code generation, making human-in-the-loop assessments essential but resource-intensive.

Despite these complexities, the community expects robust validation for professional-grade AI. This incident highlights the need for advanced testing methodologies that can identify subtle yet critical regressions in non-deterministic systems. Rebuilding developer confidence requires more than apologies; it demands a demonstrable commitment to stringent quality assurance.

Anthropic's admission extends beyond a single product misstep; it reflects a systemic challenge gripping the entire AI industry. Companies operating at the forefront of large language model development face immense pressure to innovate, delivering constant updates and new features to maintain a competitive edge in a rapidly evolving market. This relentless AI arms race often prioritizes speed over exhaustive validation.

Such rapid development cycles frequently lead to deploying changes without the comprehensive, real-world testing typical for traditional software. Consequently, unforeseen regressions can slip through, directly impacting user experience and trust. The incident with Claude Code serves as a stark reminder of these high stakes.

Evaluating the true impact of these continuous updates presents a formidable challenge. Assessing complex LLM performance, especially for creative and nuanced tasks like coding, defies simple, quantifiable metrics. While academic benchmarks like MMLU or HumanEval offer foundational insights, they rarely capture the intricate, multi-step, and context-dependent scenarios developers encounter in practice.

Traditional software testing often relies on clear pass/fail criteria or specific performance metrics. For LLMs, however, a 'better' model might exhibit subtle improvements in creativity or coherence, while a 'worse' one might suffer from reduced logical consistency or increased hallucination, all of which are difficult to objectively quantify at scale. This makes benchmarking LLM performance for practical applications incredibly difficult.

Anthropic’s adjustments to Claude Code, such as changing the default reasoning effort from 'high' to 'medium' and modifying the system prompt for verbosity, illustrate this complexity. These seemingly minor configuration tweaks, intended to optimize latency or user experience, cascaded into significant degradations in coding quality. Detecting such nuanced regressions before widespread deployment requires sophisticated, context-aware evaluation systems that the industry is still struggling to perfect.

The community's "insane" reaction regarding Anthropic's testing procedures highlights a broader industry vulnerability. Developing robust, dynamic evaluation frameworks capable of truly reflecting an LLM's utility across its vast and often subjective application space remains a critical, unsolved problem for every major AI developer.

Anthropic's recent stumble with Claude Code offers an invaluable masterclass for the entire AI industry. Development teams must internalize that seemingly minor configuration tweaks or prompt changes can cascade into significant performance degradation and user frustration. The shift in default reasoning effort from 'high' to 'medium,' implemented for speed, dramatically compromised capability for complex coding tasks.

Furthermore, the insidious 'Amnesia Bug' disrupted session continuity by causing Claude to drop its old reasoning after every idle session, making interactions feel forgetful and repetitive. Even a seemingly benign change to the system prompt, intended to reduce verbosity, significantly impacted code quality, prompting an immediate revert. These three factors collectively illustrate the profound fragility of LLM deployments when seemingly small changes are made.

Crucially, the incident underscores the distinction between the core foundation model and its specific application harness. While the underlying Claude model remained robust, the 'Claude Code' harness suffered due to these external modifications. This highlights the necessity of rigorous, multi-faceted testing for every layer of an AI product, extending beyond internal benchmarks to include extensive qualitative user feedback.

As the Better Stack video creator rightly noted, it seems "insane" to push such impactful changes without comprehensive validation. Companies cannot rely solely on quantitative metrics; real-world developer workflows and expectations demand thorough pre-production testing across diverse scenarios. This includes evaluating long-term interaction patterns, session management, and the subtle ways an AI's behavior can shift over an idle session, ensuring robustness before public release.

Ultimately, Anthropic's choice to publish 'An update on recent Claude Code quality reports' stands as a powerful testament to the long-term value of corporate transparency. Admitting fault and clearly explaining the technical missteps, even under intense public scrutiny, cultivates greater trust than obfuscation. Other AI developers should heed this example, understanding that openness, though difficult, builds resilience and credibility with their user base. For further insights into the industry's reaction, read Anthropic admits it dumbed down Claude when trying to make it smarter - The Register.

Anthropic moved swiftly to rectify the issues plaguing Claude Code. They completely reverted the system prompt change, which had significantly impacted code quality, and deployed a critical fix for the "amnesia bug" that caused Claude to drop its reasoning after idle sessions, making it feel forgetful and repetitive. The company also committed to restoring the default 'reasoning effort' from 'medium' back to 'high' for Claude Code, prioritizing capability over raw speed, and pledged ongoing improvements to performance and stability.

Regaining trust from a developer community that relies on precision demands more than just patching bugs. Anthropic must implement more robust pre-deployment testing protocols, addressing the "insane" lack of testing highlighted by the Better Stack video. This likely involves rigorous internal A/B testing, canary deployments for critical changes, and a dedicated internal developer-facing feedback loop to catch regressions before public release.

Beyond internal processes, Anthropic needs to rebuild its external reputation for dependability. This requires enhanced transparency through detailed changelogs and public roadmaps for Claude Code. Direct engagement with the developer community via dedicated forums, technical briefings, or open beta programs will be crucial for fostering renewed confidence and demonstrating a proactive approach to quality assurance.

Ultimately, the Claude incident underscores a pivotal shift in the AI landscape. Developers no longer view AI coding assistants as experimental novelties; these tools are now indispensable components of their daily workflow, demanding unwavering reliability and consistency. The future success of LLM providers hinges on their ability to deliver predictable, high-quality performance, fostering a deep sense of trust with their user base.

Why did Claude's coding performance get worse?

Anthropic confirmed three reasons: they lowered the default 'reasoning effort' to reduce latency, a bug caused it to 'forget' conversations after idle periods, and a system prompt change designed to be less verbose negatively impacted code quality.

Was the core Claude model actually dumber?

No. According to Anthropic, the core Claude model itself was not degraded. The issues were specific to the 'Claude Code' harness, which is the system and prompts wrapped around the model for programming tasks.

What changes did Anthropic make to fix Claude Code?

Anthropic has reverted the system prompt change that harmed code quality and fixed the bug that caused memory loss. They are also working on balancing latency and performance for the reasoning effort setting.

What is an AI 'harness'?

An AI harness refers to the specific set of configurations, system prompts, and instructions that are used to adapt a general base model for a specific task, such as coding. It's the application layer on top of the core model.