Context Rot — Why Long Sessions Get Stupid

Claude 4.7 has a million-token window. GPT-5 has 400k. You can hand them an entire codebase. They will read it. They will also forget half of it by the time they finish writing the answer. Long context is necessary, not sufficient — and it actively degrades reasoning quality past a point.

The long-context performance curve

Symptoms of context rot

• The agent re-asks for a file you pasted 20 turns ago
• It contradicts a constraint you set at the start of the session
• It mixes up function names from two different files you discussed
• It claims a test is passing when you pasted the failure 5 minutes earlier
• It replies more verbosely as the session lengthens (a tell that it is uncertain)

Why it happens

Attention costs scale roughly quadratically with context length. To stay tractable, models use various sparse attention tricks. These work great in benchmarks ("find the needle in the haystack") but degrade in real reasoning where you need to combine ten facts spread across the haystack. The model can still find each one. Combining them is harder.

Compaction: deliberately throwing away

# Mid-session compaction prompt for Claude Code, Cursor, Codex

"Pause. Summarize this session into a working brief:
  1. What is the goal? (one sentence)
  2. What constraints have we agreed on? (bullets)
  3. What files have we touched and how? (file -> change)
  4. What is the current bug or open question?
  5. What should NOT be touched?

Return only the brief. I'll start a fresh session with it."

Persistent memory beats long context

A 200-line CLAUDE.md, AGENTS.md, or `.cursor/rules` file at the project root is read on every session. It survives compaction. It survives session resets. Anything you find yourself repeating to the agent — conventions, scripts, gotchas — belongs in that file, not in the context window.

# Session hygiene checklist (run mentally, every 30 min)

1. Has the agent forgotten any earlier constraint? -> compact + re-state it.
2. Are we still on the original goal? -> re-state goal, drop tangents.
3. Has the file state diverged from what the agent thinks it is? -> show `git status`, force re-read.
4. Is the agent repeating itself? -> compact and reset.
5. Have we been at this >1 hour with no commit? -> hard reset.

When NOT to compact

• You're 90% done with a delicate refactor — one more push beats a reset
• The session is below 50k tokens and the agent is still sharp
• You're debugging a bug that requires the full trace history to understand

“Long context is a runway, not a destination. Land before you crash.”

The big idea: bigger context windows are a tool, not a free pass. Treat every session as a perishable resource. Compact aggressively, persist conventions in project-memory files, and start fresh when the agent's recall starts to slip. The work you save is your own.