murphy-context-rot

name

murphy-context-rot

description

What goes wrong because of the LLM context window and memory limits — the agent forgets earlier instructions, skims the middle, overflows and evicts constraints, edits blind once the project outgrows the window, and re-bills bloated history every turn. Use when planning long agent sessions, growing codebases, long chat histories, big context dumps, multi-day vibe-coding, RAG/retrieval pipelines, or any work that assumes the model "remembers" what you told it earlier. A failure-domain lens in the murphy-jutsu pre-mortem family.

Murphy: Context Rot

A failure-domain lens in the murphy-jutsu pre-mortem family — the pessimistic twin of brainstorming. Mined from ec1-dev videos.

When this lens applies

• Long single-thread sessions or multi-day agent runs where early instructions must keep holding.
• A codebase that is growing past what fits in one context window (the "day one was magic" project).
• Prompts/contexts where one load-bearing constraint sits among lots of other text.
• Habitual "paste the whole file / whole log just in case" workflows.
• Reliance on the model holding the whole project in its head, with no human reading the code.
• Cost-sensitive work where conversation length, not just call count, drives the bill.

Failure modes

Context overflow — early constraints silently evicted

• How it happens: The window is a fixed-size desk and the model has no memory; it rereads everything each turn. When the window fills, the oldest content (your initial instructions, the schema you explained) falls off the back. It isn't forgotten — it's no longer visible, so to the model it never existed. "It just woke up from a coma."
• Warning signs: The model contradicts or ignores things established early in a long session; it re-asks for info you already gave; answer quality decays the longer the thread runs.
• Mitigations: Restate load-bearing constraints late in long sessions, not just once at the top. Compact old turns into a short decisions-only summary instead of dragging raw transcript. Start a fresh window per task. Monitor token usage against the window limit so you see overflow coming.

Lost in the middle — positional skim

• How it happens: Even when everything fits, the model attends to the start and end of context more than the middle, "treating the middle like the terms and conditions." A critical instruction buried mid-context gets skimmed past.
• Warning signs: The one important rule in a long prompt is ignored while the ones around it are followed; behavior changes depending on where in the prompt you place a rule.
• Mitigations: Put the single most important constraint at the very top OR the very bottom of context, never the middle. Don't bury constraints in the soft middle. Keep prompts lean so there is less middle to lose things in.

Context bloat / distraction — more is not better

• How it happens: Stuffing the window with everything "just in case" doesn't make the model smarter, it makes it distracted — signal drowns in noise. The model can't tell your important file from random scratch notes; that curation is the human's job, not the model's.
• Warning signs: Answers get vaguer and less focused as you add context; the model latches onto irrelevant pasted material; relevance drops as input size grows.
• Mitigations: Curate context to what the task actually needs; don't dump whole files/logs by default. Fetch chunks on demand (retrieval) rather than hoarding everything up front. Own the relevance filtering yourself — don't expect the model to ignore the noise you handed it.

The token meter — bloat is a recurring per-turn cost

• How it happens: Every token in the window is reprocessed on every turn. A bloated context isn't merely dumber — it re-bills the entire window on each message, compounding cost across a long session (the "$900" war story). A tiny new message on top of a huge history still pays for the whole history.
• Warning signs: Token/$$ bills rising faster than expected in long sessions; cost scaling with conversation length even when each new message is small.
• Mitigations: Compact history aggressively; start fresh windows for unrelated tasks. Keep context lean to cap per-turn cost. Track cost-per-turn, not just cost-per-call.

Editing blind — the project outgrows the window

• How it happens: Vibe coding feels flawless on day one only because the whole project (four files) fits in context. As it grows past what fits, the model patches what it can see and breaks what it can't — "every fix is a fresh bug wearing the fix's clothes." The very property that made day one magic is what fails at scale.
• Warning signs: A "small change" rewrites unrelated parts (the login page vanishes, a second database appears); the same operation implemented in many places (a card charged in nine); fixes that spawn new bugs; edits touching files unrelated to the task.
• Mitigations: Assume quality degrades once the project exceeds the window — plan for it before it happens, don't trust day-one smoothness to last. Keep modules small and bounded so edits stay local and never require the whole project in context. "If it can't hold the whole thing, don't make it." Watch duplication and rewrites of untouched code as the tell that the model is editing blind.

Agent amnesia — re-deriving architecture from its own code

• How it happens: Across sessions the agent has no memory of its own past decisions, so each session it re-derives the architecture by reading code it wrote in earlier forgetful sessions that don't agree with each other. Finding two functions that do the same thing, it can't tell which is canonical, guesses, and adds a third. "The codebase is its memory, and you let a goldfish write the memory."
• Warning signs: It re-implements functions that already exist; rebuilds whole subsystems it already built (login on day 6); duplicate functions with the same name; the same files rewritten every session.
• Mitigations: Persist architecture/decisions in a durable doc the agent reloads at the start of every session — "decisions, not vibes" — not just in chat that scrolls off. Make canonical implementations discoverable so the agent doesn't guess. Alarm on duplicate function names and repeated rewrites of the same file.

Pre-mortem questions

1. Which constraints do we assume the model still remembers — and what happens to them when the window overflows late in a long session?
2. Is our single most important instruction at the edge (top/bottom) of context, or buried in the middle where it gets skimmed?
3. Are we curating context to what the task needs, or dumping whole files/logs "just in case" and distracting the model?
4. Do we start a fresh window per task, or drag long unrelated history forward and pay to reprocess it every turn?
5. How do we compact old conversation — keep decisions, drop transcript — rather than trusting a built-in compactor?
6. Will this project outgrow the window, and what happens to edit quality when the agent starts editing blind?
7. Where does the agent's memory of past decisions live — and if it's only the codebase, what stops it re-deriving and contradicting the architecture each session?
8. Do we monitor token usage and per-turn cost so a bloated context doesn't quietly run up a $900 bill?

Mitigations checklist

• Put the single most important constraint at the top OR bottom of context, never the middle.
• Restate load-bearing constraints late in long sessions; don't rely on early statements persisting.
• Start a fresh window per task instead of dragging history forward.
• Compact old turns into a decisions-only summary; drop the raw transcript.
• Curate context to what the task needs; don't dump whole files/logs just in case.
• Fetch information on demand (retrieval) rather than hoarding it all up front.
• Persist architecture/decisions in a durable doc the agent reloads each session, not just in chat.
• Keep modules small and bounded so edits stay local and don't need the whole project in context.
• Watch for duplicated functions and rewrites of untouched code — the tell of editing blind.
• Monitor token usage against the window limit, and track cost-per-turn, not just per-call.

Recurring motifs

• "The context window is not memory, it's a desk. A bigger desk does not make you organized — it just gives you more surface area to lose the one document you needed." — more is not better.
• "It just woke up from a coma... don't, and you'll keep explaining your schema to a coma patient." — the model rereads from zero each turn.
• "The codebase is its memory, and you let a goldfish write the memory." — a mansion the agent walks with one flashlight.
• "Every fix is a fresh bug wearing the fix's clothes." — what editing blind feels like at scale.

Source videos

• Why Your Vibe Coding Agent Dies on Day 6 — transcripts/08_vibe-agent-dies-day-6/
• vibecoding works on day one. there is no day two — transcripts/12_vibecoding-no-day-two/
• why does my ai forget everything i tell it — transcripts/15_ai-forgets-everything/