What Is Context Rot? (And How to Fix It Fast)

You were ten minutes in and the AI was sharp. It knew your file structure. It remembered the constraint you set early on. It was finishing your sentences in the right direction.

An hour later, it's contradicting itself. It's regenerating code you already told it to scrap. It's ignoring a decision it acknowledged three turns ago. Nothing in the tool has changed — the session is still open, the context window isn't full, and yet the AI feels like a different model than the one you started with.

That's context rot. And most beginners don't know it has a name.

Why Your AI Gets Worse the Longer You Work

The symptom most beginners mistake for a bug

The experience usually starts subtly. The AI's responses get a little more generic. It asks you to clarify something you already explained. Then it actively contradicts itself — suggesting an approach it already told you to avoid, or reverting a decision you both agreed on earlier.

The instinct is to think the AI is broken, or that you phrased something wrong. But the problem isn't in your last message. It's in the accumulated weight of everything that came before it.

Context rot vs. a full context window — two different problems

This is the most important distinction to make. If you've read about context windows in AI coding tools, you know about the hard limit — the point where the AI literally runs out of room and starts forgetting the oldest parts of your conversation.

Context rot is different. It's not about running out of space. It's about what fills that space.

A context window full of clean, relevant, signal-rich content performs well right up to its limit. A context window polluted with noise — failed attempts, error logs, verbose outputs, repeated file scans, abandoned tangents — starts degrading long before the limit is reached. The AI still has plenty of room. It just has too much garbage competing with the signal.

The fix for a full context window is a fresh session. The fix for context rot is flushing the noise — sometimes without even starting over.

What Context Rot Actually Is

How noise accumulates in a session

Every message in a session takes up space, but not all content is equally useful. Noise builds up from:

• Failed attempts — you asked for something, the AI got it wrong, you corrected it, it tried again. Three turns of noise for one piece of working output.
• Verbose tool output — long error logs, full file reads, stack traces pasted into the chat. Relevant at the time, dead weight afterward.
• Repeated context — you've mentioned the same constraint five times across five different questions. The AI's acknowledgements of that constraint are now taking up five times the space of the original statement.
• Abandoned directions — you explored one approach, decided against it, and pivoted. That entire sub-thread is still in context, including the AI's reasoning for the approach you're no longer using.
• Irrelevant file reads — the AI scanned files early in the session that have nothing to do with the current task. Those tokens are still loaded.

None of this is a mistake — it's how sessions naturally evolve. But each item shifts the ratio of signal to noise, and the AI weighs everything in context roughly equally when generating its next response.

The signal-to-noise ratio collapse

The AI doesn't filter the history. It processes the full context on every turn. When a large fraction of that context is noise — failed attempts, abandoned branches, stale tool output — the model's attention gets spread across content that no longer matters.

Research suggests that AI coding sessions show meaningful degradation in response quality beyond 40 turns, with some estimates placing the threshold for noticeable drift even earlier. These numbers aren't precise across all models or tools — they reflect patterns observed across sessions, not a hard cutoff. What matters is the mechanism: more turns means more accumulated noise, and more noise means lower signal density.

Why the AI doesn't warn you

This is what makes context rot insidious. The AI has no way to flag it. It doesn't know which parts of the conversation are still relevant to you. It processes what's there and responds. There's no "signal dropping" indicator, no "context quality" meter, no alert that says "your session has accumulated a lot of noise — consider compacting."

You have to catch it yourself, and you have to know what to look for.

How to Diagnose It

Signs you have context rot right now

Run through this checklist when a session starts feeling off:

• The AI is contradicting decisions it acknowledged earlier
• Responses are longer and vaguer than they were at the start of the session
• The AI is re-asking for context you already provided
• It keeps incorporating a discarded approach into new suggestions
• It's adding caveats and qualifications that weren't there in earlier responses
• You've had to repeat the same constraint more than twice

If three or more of these are true, you're not dealing with a bad prompt. You're dealing with context rot.

The 35-minute / 40-turn rule of thumb

Research suggests that meaningful session degradation often starts to appear around 35 minutes of sustained AI-assisted work, with significant quality drops becoming common beyond 40 back-and-forth turns. Treat these as rough heuristics, not precise thresholds — the actual onset depends on how noisy the session has been, not just how long it's run.

A clean, well-scoped session at turn 50 can outperform a messy, tangent-heavy session at turn 20. The clock isn't the cause — the noise is. But if you're past 35 minutes or 40 turns and things feel off, context rot is the first thing to rule out.

Three Fixes You Can Run Right Now

Fix 1 — Start a fresh chat and reload only what matters

The most reliable fix for severe context rot is also the most obvious one. Close the current session. Open a new chat. Start with a clean summary of where you are.

The summary doesn't need to be long. Three to five sentences covering:

1. What you're building (the specific task, not the whole project)
2. What's already working
3. The key decisions that are locked in
4. What you need next

This strips out every failed attempt, every discarded approach, every stale file read, and gives the AI only the signal it needs to be useful. You lose nothing that mattered — if it mattered, you just wrote it down.

Fix 2 — Move persistent decisions into a reference file

If you find yourself repeating the same constraints across sessions — same naming conventions, same architectural decisions, same "don't do X" rules — you're burning context budget on things that should be structural.

In Claude Code, this is what CLAUDE.md is for. It loads at the start of every session, before the conversation even begins. Decisions you write there don't compete with your chat history — they're always present, always clean, and don't accumulate the noise that mid-session repetition does.

Cursor and Windsurf have equivalent files — .cursorrules and Windsurf's project rules respectively. Writing a well-structured CLAUDE.md is one of the highest-leverage habits you can build for long-session work. The same principles apply in any tool.

Fix 3 — Use compact or summarize commands where supported

Starting a fresh session isn't always the right move, especially if you're mid-task and want to preserve some continuity. Several tools offer native commands to compress the existing context rather than discard it entirely.

In Claude Code, /compact summarizes the current session and replaces the full history with a compressed version that preserves the key decisions and outcomes. This can recover a significant amount of signal-to-noise ratio without forcing a full restart.

Cursor has a /summarize slash command (added in Cursor 1.6) that compresses the current chat history on demand — useful when you want to free up context space without starting over. Windsurf's Cascade handles this automatically, periodically summarizing older messages as a session grows, so there is no manual command to run. In both cases, the mechanism exists; in Cursor you trigger it explicitly, in Windsurf it happens in the background.

If your tool supports it, use /compact (or its equivalent) before the session fully degrades rather than after — it works better on a context that still has some signal left than on one that's deeply polluted.

How to Prevent It Next Session

Keep sessions task-scoped, not project-scoped

The fastest way to accumulate context rot is to use a single session as your entire project workspace. One long session for a whole feature — routing, state management, component design, bug fixes, refactors — will be carrying an enormous amount of noise by the end.

One task per session is a better default. Not one project, not one feature — one concrete task. Finish it, commit the result, and open a fresh session for the next piece. Each session starts clean and stays dense with relevant signal.

Front-load your constraints before you start

Context rot accelerates when the AI has to learn your constraints mid-session through trial and error. Every failed attempt that results from the AI not knowing a rule you hadn't stated yet is pure noise.

Front-loading — stating your key constraints, decisions, and non-negotiables in the first message — reduces failed-attempt noise significantly. Pair this with a reference file for anything that applies across sessions. See how to write better prompts for AI coding tools for techniques that apply directly to this.

What Claude Code, Cursor, and Windsurf each let you do natively

Each tool gives you slightly different handles for managing session quality:

• Claude Code — /compact for in-session compression; CLAUDE.md for persistent context; agentic tasks that complete in fewer turns tend to accumulate less noise than long back-and-forth conversations
• Cursor — /summarize slash command for on-demand context compression; Agents Window keeps context scoped to the active task; .cursorrules for persistent project rules; inline edit mode (Cmd+K / Ctrl+K) runs with a narrow local context that's naturally resistant to rot
• Windsurf — Cascade automatically summarizes older messages as sessions grow long; visual context indicator shows current usage; project rules file for persistent constraints; Cascade still benefits from scoped sessions even with auto-summarization

None of these tools solve context rot automatically. They give you the tools — you still have to recognize the signs and act on them.

If the session output is already broken by the time you catch it, how to fix AI-generated code covers recovery steps that work regardless of what caused the degradation.

---

Context rot is the problem that doesn't announce itself. The AI doesn't tell you the session is polluted. It just starts underperforming, and most beginners blame their prompts. Now you know the real cause — and you have three concrete ways to stop it before it costs you another hour.

The highest-leverage next step: set up a CLAUDE.md file for your current project. It's the one thing that reduces context rot before it starts, not after.