Why Claude, GPT & Gemini Keep Getting Worse

A director at AMD got tired of arguing about a feeling, so she brought data. Stella Laurenzo logged 6,852 Claude Code sessions, 234,760 tool calls, and nearly 18,000 reasoning blocks, then filed a public report showing the model she relied on had quietly gotten worse. It was reading code far less before editing, rewriting whole files more often, and abandoning tasks at rates that used to sit at zero. Anthropic’s first move was to close her report and point at her settings.

That story is not a one-off. Every major lab, OpenAI, Anthropic, and Google, has faced the same accusation, and the script rarely changes. This article walks through why it keeps happening: the money behind it, the technical levers that cut quality, what each company has actually admitted, and what you can do so your own systems do not silently rot.

Are AI models actually getting worse?

Sometimes, yes, and it is documented. There are confirmed cases where a major model got measurably worse after launch, complete with company postmortems. There is also a large pile of complaints that turn out to be perception rather than measurable decline. Both are true at once, which is exactly why the topic is so confusing.

The reason the debate never settles is that real regressions and imagined ones produce the same symptom: your stuff stops working as well as it did. Without controlled tests you cannot separate “the model changed” from “I got used to it.” That ambiguity is also what lets companies wave away genuine problems as user error.

Underneath the noise, the same four-beat pattern repeats for nearly every model. It launches to praise, quietly degrades, gets denied, and then someone publishes the receipts.

What silent degradation feels like for developers

From a developer’s seat, degradation shows up with no error code and no changelog. You write a prompt on Monday that returns clean code. By Thursday the same prompt returns a skeleton full of TODO comments where the logic should be. A classification pipeline that held 94% accuracy drifts to 87%. Nothing in your code changed, so you spend hours wondering if the problem is you.

def parse(row):
    name, age = row.split(",")
    return {"name": name,
            "age": int(age)}

def parse(row):
    # TODO: split the row
    # TODO: handle the age
    pass

The disciplined response is to stop trusting the vibe and start measuring. Some teams run regression tests on a schedule, sending the same prompts and tracking output quality over time. One developer generates a poem at zero temperature every day just to see if the words shift. Most people, though, catch it the hard way: production breaks, and only then do they go looking.

Why would a company make its own model worse?

Almost never on purpose, and almost always because of cost. Serving these models is expensive, the price customers pay has collapsed, and margins are thin to negative. When revenue per query falls but the GPU bill stays huge, the pressure to serve cheaper responses becomes constant, and “cheaper” and “slightly worse” often look identical from the inside.

The numbers tell the story plainly. Estimates put the cost of a single GPT-4 query near 36 cents at launch, OpenAI’s annual inference spend has been reported in the billions, and at the same time the headline price of capable models has fallen roughly 200x in well under two years. You cannot drop prices that fast without changing how the model is served.

So no one needs to decide to ship a worse product. They decide to ship a cheaper one, and quality becomes the variable that quietly gives.

How do quantization and routing quietly cut quality?

Through two levers that change what you get without changing the model’s name. The first is quantization, which compresses the model’s weights to lower numerical precision so it runs on less hardware. The second is routing, which sends your prompt to a different, cheaper model depending on how hard the system thinks it is. Neither shows up in the product label.

Quantization is usually safe in moderation. Running at FP8 precision costs almost nothing in quality, and Red Hat’s evaluations across hundreds of thousands of tests found near-full accuracy recovery. Push down to 4-bit and complex reasoning takes real hits, because a small precision error early in a chain of thought can cascade until the model is confidently wrong by the end.

Routing is the sneakier one. OpenAI has confirmed that GPT-5 uses a real-time router that picks between models based on the conversation, so selecting one name does not guarantee one model. Research like RouteLLM shows you can send most traffic to a cheaper model and still retain around 95% of the score on standard benchmarks. The catch is in that last phrase: benchmarks do not capture the prompt-sensitivity and formatting quirks developers actually feel.

What has each AI company actually admitted?

More than you might expect, because this is not all speculation. The strongest cases come with the companies’ own words. The table below lines up the confirmed incidents, the one Anthropic dragged its feet on, and the Google claim that remains unverified.

The receipts are concrete. In December 2023, OpenAI acknowledged complaints that GPT-4 had gone lazy and later shipped a fix. In 2025 it rolled back a GPT-4o update and, in its sycophancy postmortem, blamed over-weighting short-term thumbs-up feedback. Anthropic’s postmortem on three recent issues is the most transparent of the bunch: a routing bug sent up to 16% of Claude traffic to the wrong server pool, and a separate bug injected stray Thai and Chinese characters into English replies. None of it was intentional.

Google sits at the other end of the openness scale. Users reported finding the line EFFORT LEVEL: 0.50 in Gemini’s hidden system prompt and said they reproduced it many times, but Google never confirmed it and reporting found no hard evidence that the product actually halves effort. Treat that one as a loud anecdote, not a proven fact.

Is it real degradation or shifting expectations?

Often it is the second one, and the cleanest example is the study that started the panic. In 2023, a Stanford and Berkeley paper appeared to show GPT-4’s accuracy at identifying prime numbers collapsing from 97.6% to 2.4% in a few months. It spread everywhere as proof the model had been gutted.

Then Princeton researchers Arvind Narayanan and Sayash Kapoor checked the work. As they explain in their rebuttal, the model had not gotten worse at math. It had simply flipped from guessing “prime” for everything to guessing “not prime” for everything, and since the test contained only primes, that flip swung the score from near-perfect to near-zero. Both versions were equally bad at the actual reasoning.

Benchmarks do not rescue you here either. Frontier models cluster above 90% on the standard suites, so the differences fall inside the noise, while the things developers feel, prompt sensitivity, formatting drift, and subtle reasoning slips, live on dimensions those tests never measure. The honest position is that some decline is real, some is perception, and you usually cannot tell which without your own controlled tests.

How developers can defend against model drift

You defend against it the same way you defend against any flaky dependency: assume it will change and build guardrails. Four moves cover most of the risk, and they stack from cheap to involved. None of them require trusting a vendor’s roadmap.

Pinning a dated snapshot buys stability until the provider deprecates it, which they eventually will. Evals are the real workhorse: tools like promptfoo let you define expected behavior and run it in CI, so quality drops fail the build before they reach users. Treat model output like any other untrusted external input. Add a gateway such as LiteLLM for multi-provider fallback, and for stable, high-volume workloads, weigh local open-weight models, which never change after you download them.

The real problem is opacity, not malice

Here is where it lands. There is no confirmed evidence that any company swaps in a weaker model under the same name as a deliberate strategy. What there is evidence of is messier and more ordinary: infrastructure bugs that run for weeks, cost-saving features that cut reasoning depth, routers that send your prompt somewhere cheaper without telling you, and products that change without a changelog.

The issue is not that these companies are evil. It is that they hold all the information and you hold none of it. They know which model answered, what precision it ran at, and whether your request got the premium path or the discount one. You get a response and a vibe.

Cloud computing went through this exact growing phase. Uptime was a vague promise until customers demanded SLAs with financial penalties behind them. AI needs the same thing, not just latency guarantees but quality guarantees tied to measurable output. Until that arrives, treat every model API like the ground could shift under you at any moment, because it will.

For the full version of this story, the AMD report, the postmortems, and the receipts in about eight minutes, watch the explainer on YouTube.