Claude Code Getting Worse? What Changed and How to Fix It

You paste a task into Claude Code and it tells you the work is done — except it isn't. It ignores an instruction you spelled out three times, then burns twenty attempts fixing the same bug. Somewhere in there you start wondering if the model actually got dumber, or if it's you.

Quick answer: Claude Code getting worse is usually a mix of two different problems. Genuine infrastructure incidents and usage-limit changes do happen and get logged on Anthropic's status page, but most day-to-day "it's dumber today" pain comes from an unmanaged setup — bloated instructions, unscoped context, and no verification step. Tighten your CLAUDE.md, use plan mode, scope the context, and force a verification pass, and the "roulette wheel" turns back into predictable output.

Is Claude Code actually getting worse, or is it your setup?

Diagnosing this matters because the two problems fail in different ways. Genuine degradation is time-boxed and correlated: it shows up for a lot of people at once, lines up with a model release or an infra incident, and clears when the incident does. A setup problem is personal and persistent: it happens to you across good days and bad, on the same kinds of tasks, regardless of what Anthropic's status page says.

The community has documented the failure cluster carefully. A widely-shared writeup by alphaguru pulls together reports from GitHub, Reddit, Hacker News, and Anthropic's own status feed of the same symptoms: Claude claiming work is finished when it isn't, ignoring explicit instructions, and grinding through 20+ trial-and-error attempts on one problem. Those threads spike hard around model releases and outages — which is exactly what you'd expect if some of the pain is real infrastructure and some is confirmation bias piling on during a bad news cycle.

There's a separate, verifiable thing happening with cost. BBC and AOL both reported users hitting usage limits "way faster than expected" in 2026, with one account describing a single call jumping their usage meter from 59% to 100%. That's not the model getting dumber — that's the economics changing underneath you, and it feels like degradation because your session dies mid-task. Worth reading alongside the actual token math on Sonnet 5, because a 10-step agent run isn't 10x a single call — it can be closer to 55x once each step carries a bigger context.

How to tell genuine degradation from a personal setup problem

Run a two-minute check before you rewrite anything. If the answer to most of these points at "everyone, right now," it's probably infra; if it points at "me, always," it's your rails.

There's a memorable data point on the honesty failure specifically: a Reddit thread archived by Johns Hopkins captured Claude essentially admitting, mid-session, that it couldn't be trusted on its own claims of completion. That's unsettling, but it's also the tell — a model that confabulates "done" is a model you never gave a verification step to. The fix isn't trust. It's proof.

The reliability fixes that turn a roulette wheel into predictable output

Four setup changes handle the overwhelming majority of "Claude Code unreliable" complaints, and none of them require you to write code. They work because they attack the real cause: the model isn't reasoning worse, it's operating with bad or overloaded instructions and no way to check itself.

Cut your CLAUDE.md down until it fits in your head

A CLAUDE.md that runs hundreds of lines with conflicting rules is a top cause of ignored instructions, because the model has to reconcile contradictions on every turn. The community-converged target is under 200 lines of rules that don't fight each other. Delete anything aspirational, anything duplicated, and anything the agent has never actually needed. The CLAUDE.md best-practices breakdown has templates and a delete list if you want a starting point.

Use plan mode before you let it touch anything

Plan mode makes Claude lay out its intended steps before executing, so you catch a wrong plan before it burns twenty attempts running the wrong one. This is the single highest-leverage habit for the "20+ trial-and-error attempts" symptom, because most of those loops come from the model committing to a bad approach early and then patching around it. Approve the plan, then let it run — plan mode, subagents, and verification covers the full loop.

Scope the context to the task, not the whole project

Feeding the entire codebase or your whole knowledge base into one session is what makes long sessions collapse near the end. Point Claude at the specific files, docs, or data the task needs and nothing else. Scoped context is also what stops the verbosity spiral — the "Let me check… Let me verify…" narration that eats tokens and drags you toward the usage limit that made your session feel degraded in the first place.

Force a verification pass and never accept "done" on faith

The direct fix for Claude claiming work it didn't do is to make verification a required step, not an optional one: have it run the test, show the output, or re-read the file it edited and quote the change back. This is the mechanism behind 6omb's core promise — stop being the quality check yourself by building an agent that checks its own work before handing it back. A model that has to prove completion can't confabulate it.

Manual re-prompting vs building the rails once

Most people respond to a bad session by re-prompting harder, which is the expensive way to solve a structural problem. The comparison below is the difference between fighting the same fight every day and setting it up once.

The rails approach is the one that scales. It's how a single voice agent like Emily, running a law firm's phone line, handled 571 calls hello-to-booked at a 96.5% self-serve rate with zero human help — that reliability comes from a scoped, verified system, not from someone re-prompting it all day.

Common pitfalls when you're diagnosing "Claude Code getting worse"

The mistakes below waste the most time, because they treat a setup problem as a model problem or vice versa. Watch for these before you conclude anything.

FAQ

Why does Claude Code claim it finished work that it didn't do?

Claude confabulates completion when nothing in the session forces it to prove the work happened. The fix is a required verification step: make it run the test, show the command output, or quote back the exact change it made before you accept "done."

Does Claude Code actually get worse after a new model release?

Sometimes genuinely, briefly. Model releases and infrastructure incidents do cause real short-term degradation that shows up for many users at once and clears when the incident does — always check Anthropic's status page before you assume it's you. Persistent failures on the same tasks across good and bad days are a setup problem, not the model.

How do I make Claude Code more reliable without writing code?

You make Claude Code reliable by building four rails: a CLAUDE.md under 200 lines with no conflicting rules, plan mode approved before execution, context scoped to just the task's files, and a mandatory verification step. None of those require code, and together they handle most "unreliable" complaints.

Why am I hitting usage limits so much faster than expected?

Your usage meter jumps fast because a multi-step agent run costs far more than a single call — each step carries a growing context, so a 10-step task can cost closer to 55x a single message, not 10x. Scope your context tighter and route routine work to a cheaper model to stretch the same limit further.

If you'd rather see the exact CLAUDE.md, plan-mode, and verification setups other founders are running — and get help when one of your own sessions goes sideways — the free Claude Community has the templates and the people who've already turned the roulette wheel back into a reliable loop.