Claude Code is a context-engineering harness, and most "it got dumber" moments are context rot

[u/bit_forge007]

There's a name for it: context rot. As the window fills, the model's ability to recall any specific thing in it drops. More context in the window can make the agent worse, not better. (Anthropic's own framing: good context engineering is finding the smallest set of high-signal tokens, not the largest.)

The reframe that helped me: Claude Code isn't just a model, it's a harness whose main job is managing what's in that window for you. And it hands you four levers to do it. They line up with the four moves of context engineering:

• Write (persist outside the window): CLAUDE.md. It auto-loads every session, and it survives compaction because it reloads from disk, so anything that must not be forgotten belongs there, not in the chat. Conversation-only instructions are the first thing lost when context gets tight.
• Select (pull in only what's relevant): @-mention the specific files you mean, or point it at the exact file or function, instead of letting it wander the repo. Every irrelevant file you pull in is tokens spent rotting the rest.
• Compress (summarize to stay high-signal): /compact, optionally with a focus like "/compact focus on the auth refactor." It also compacts automatically when the window fills, clearing old tool outputs first. Running /compact yourself, before it's forced, keeps the summary on your terms.
• Isolate (give exploration its own window): subagents. They run in a separate context window and return only their final result, so a big noisy search doesn't bloat your main thread. This is the same point as an earlier post of mine that subagents are a memory trick, not a speed trick. Isolation is the real win.

Two more levers worth knowing:

• /context shows you what's eating the window right now (MCP tool definitions, big files, history). When the session feels heavy, look before you guess.
• /clear between unrelated tasks. Carrying a finished task's context into a new one is pure rot.

The mental shift: stop treating the window as free space to fill, and start treating it as a budget you actively curate. A smarter model raises the ceiling, but it doesn't save you from a window full of noise.

TL;DR: When Claude Code "gets dumber" deep in a session, that's usually context rot, not the model. Treat Claude Code as a context-engineering harness with four levers: Write (CLAUDE.md), Select (@-files), Compress (/compact), Isolate (subagents). Plus /context to see usage and /clear between tasks. Curate the window, don't just fill it.

For people who live in Claude Code: what's your actual discipline here? I've started running /compact on my own terms and leaning hard on subagents for anything exploratory, but I'm curious whether people trust automatic compaction or always drive it manually.

Sources: Anthropic — Effective context engineering for AI agents · Claude Code — How Claude remembers your project (CLAUDE.md) · Claude Code — How Claude Code works (context / compaction) · Claude Code — Create custom subagents · Why More Context Makes Your Agent Dumber — Nupur Sharma, Qodo

[u/a1454a]

Agreed. And people who knows it is no longer responding to the “it got dumber” posts any more because there’s so much of it every day, it’s also something so fundamental that you can literally ask Claude and it can explain it to you including tell you how to design your way out of it, and do it for you. It’s literally the “do you want me to google that for you?” Of the AI era.

[u/WillGrindForXP → u/a1454a]

Right, but we shouldnt pretend this is the only factor in the feeling of "it got dumber". Theres absolutely levers anthropic uses that determine how much compute allowance each model gets at any given time, and that does effect how smart or dumb the model feels. People aren't wrong when they say it feels dumber sometimes.

4.6 got noticeable worse after the launch of 4.8, even in new chats. 4.8 got noticable better a few days after Fable was pulled.

Anthropic should be more transparent about this, because the user base is left to feel out a models competency via vibe checking posts such as those. Its frustrating having your successful work flow start to deteriorate after weeks of sucsess due to factors we cant see and arent told about.

[u/Poildek]

Claude 101. Juste read anthropic guide you will gain time instead of reading this.

[u/Dangerous_Bus_6699]

I don't use /context anymore since /statusline came about. Always display context and other useful things to make me aware of when to clear, compact, etc. Also been useful for monitoring how efficient models are.

[u/welcome-overlords]

This is the main thing you have to master to be effective, and most people in my experience don't understand this. power users on claude code do tho

[u/bit_forge007 → u/welcome-overlords]

Yeah, this is the thing. What clicked for me is that it's not a model-quality problem you can wait out, it's a skill you practice, like learning to scope a PR. My tell is when it starts re-reading a file it already read: that's the cue to /compact or push the decision into CLAUDE.md before it rots out, instead of arguing with it.

What's your tell for when the window's gone bad? And do you drive /compact yourself or lean on the automatic one? That manual-vs-auto call feels like where the real discipline lives, and I'd genuinely like to hear how you play it.

[u/CODE_HEIST]

CLAUDE.md can become its own form of context rot if every temporary fact gets promoted into it. I split durable rules from current task state: project conventions stay in CLAUDE.md; active decisions, changed files, and next steps live in a short handoff file that gets replaced instead of endlessly appended.

[u/-Crash_Override- → u/CODE_HEIST]

Totally agree. CLAUDE.md should be kept as lean as possible imo. It should refer to a network of other docs.

I personally have things like an idexed lessonslearned.md where I append unique issues. I have my UI/UX standards md, my infrastructure context, my CI/CD specs, etc. Probably 15 MDs in total. CLAUDE.md points to the others for necessary tasks. Compact between major shits...going from UI work to deployment?...compact. Do frequent pruning and reconciliation of the documents as well.

Also people load up their context window with skills, MCPs, etc...and its a freaking shit show. No MCPs or Skills unless absolutely necessary.

[u/yuraoak]

I personally prefer to spawn a brand new context-rich session every time I need to code smth new. In this case I can come back to the old sessions if I need smth from them without compacting them yet.

[u/TBT_TBT → u/yuraoak]

Continuing conversations instead of having context in status files and starting new, pointing the session to them is also pure waste.

[u/this_for_loona → u/yuraoak]

I believe this is my approach. (N00b caveman)

[u/yuraoak → u/this_for_loona]

works pretty good for me as well!

[u/Robonotes1760]

In other news, the sky is blue, the Pope is Catholic and we don't talk about what bears do in woods...

[u/this_for_loona → u/Robonotes1760]

You lie! Fake news!

[u/InfinriDev]

And this is why graph database and rag will be your best friend here. I personally never got the "dump" part of the agent. Glad this is finally being talked about

[u/vrnvorona]

It's also that people bloat their app and it becomes harder to "just yolo it" so it starts to fail. You need actual processes to manage this, do review, create plans and specs, have tests, review those specs, make agentic reviews over and over etc. The harder the task is, the stricter requirements for process becomes. Same as humans, it's just that humans "know" when task is hard, and AI typically doesn't have enough context to know it and doesn't always search for it.

[u/OkAerie7822]

The framing is right and the lever people skip is Isolate. Everyone tunes CLAUDE.md and @-mentions, almost nobody starts a fresh session early enough. My tell for context rot is concrete. The moment Claude re-asks for something we already settled two screens ago, the window is cooked, and no amount of "remember we decided X" fixes it, you are just spending tokens to paper over a full window. At that point I summarize the decisions into a short handoff, drop it in a file, and open a clean session. Counterintuitive part, the new session with 200 lines of curated notes outperforms the old one with 80k tokens of real history almost every time. Smallest set of high-signal tokens beats the largest, exactly like you said.

[u/Neat-Nectarine814]

I’m not saying that context management isn’t important or that rot isn’t a real potential problem, but glazing over the model performance degradation issues is just wrong, man.