Find the sentence you'd type at midnight.
Split by what you're actually feeling: the AI went blank mid-task, the same work is quietly costing more, nobody can say why the code is there, or the sessions you left running need you.
Every number cited across these pages is pulled from production telemetry, a public bug report or our own project record, not invented for the page. Each one also names what people try first, and where that stops working, before it says what actually helps.
The forgetting, mechanism by mechanism.
| What you're seeing | The mechanism |
|---|---|
| compaction fired, then it went thin | The recap keeps the conclusion and drops the work behind it, every time, on purpose. read the mechanism → |
| you don't know what got deleted | Mostly tool results, and you pay for the loss twice: once in the summary, once in the cache miss. see what goes → |
| it's worse than it was an hour ago | Nothing has dropped yet. The decay starts before compaction ever fires. read the decay curve → |
| the context bar won't move | The ceiling where /compact stops being a choice and starts being forced. read what to do → |
The same problem, priced.
| What you're seeing | The cost |
|---|---|
| every reply feels slower than the last | Re-sending a growing transcript on every call compounds. The bill grows like a triangle, not a line. read the bill shape → |
| the bill spiked and the work didn't change | An idle gap, a model switch, a bad automation interval: any of them breaks the cache, and the next turn prices in full. find the break → |
| caching is on and it's still expensive | Caching taxes repetition. It never lowers what the model has to read, and the prompt keeps growing underneath it. read what caching misses → |
Nobody can say why the code is there.
| What you're seeing | Why it happens |
|---|---|
| why is this code here? | The reason for a change exists once, at the moment someone decides it. If nothing writes it down then, every later explanation is a story fitted to the diff. read it → |
| lgtm on a 60-file pr | AI made writing code much faster and left reading it exactly as slow. A review only counts if it checks something the tests don't already cover. read it → |
| did a human decide this? | Humans are still accountable for the code that ships, whether they reviewed it or not. That only works if you can tell a person's call from a model's suggestion after the chat is closed. read it → |
| duplicated logic | A session writing new code starts empty, and it searches for names, not ideas. Duplicates are the same idea under a different name, so they slip through. read it → |
| comments that mean nothing | A model writes comments for the next model, packed with shorthand from a session you never saw. Notes for a model and sentences for a person need to be kept apart. read it → |
| ten paragraphs to defend one line | An explanation written after your question is built to sound reasonable, not to remember what happened. A record made at the time beats a fluent account made later. read it → |
| your AI reviewing your AI | Agreement between two copies of one model isn't a second opinion. A review earns its keep by seeing different inputs and breaking things on purpose. read it → |
| too much ai output to read | Most of what AI sessions write is bookkeeping, and the few lines that need you arrive in the same stream. Separating the two is a design job, not a reading habit. read it → |
The sessions you left running.
| What you're seeing | Why it happens |
|---|---|
| running claude code overnight | A session stops when its turn ends, and a fresh one starts with no memory. Unattended work needs the plan and the work list to live outside any one session. read it → |
| every session starts from zero | The model keeps nothing between sessions, so whatever the next one knows has to be written down and read back. A short handoff, read first, carries the work across. read it → |
| which session needs me? | A terminal reports nothing on its own, and a session's last message says what it meant to do. Telling the sessions apart needs state reported from outside the model. read it → |
| planner, builder, reviewer | Separate sessions can't see each other, so without something shared between them you become the link. One task list, taken one task at a time, removes the middleman. read it → |
| handoffs nobody reads | A new session starts with whatever it's handed and nothing else. A handoff only works if reading it is part of starting up. read it → |
Where AI failure modes fits.
The pages above each explain one mechanism. AI failure modes is a different kind of page: ten foundational facts and ten operator practices for the working relationship itself, each cited to a real logged incident. Read it when the question isn’t “why did this happen,” but “how do we work together so it happens less.”
Common questions.
Is this the same as retrieval or RAG?
The compaction and cost pages stay inside one conversation. How memory works across sessions is the encyclopedia’s question: start with substrate memory, its cornerstone.
Does a bigger context window fix this?
It raises the ceiling inside one session. The record still lives only in that session, so a fresh one starts blank again. the longer version is here.
Are these specific to Claude Code?
The receipts happen to be measured there: it's where the loudest bug reports are. The mechanism, a stateless model re-reading a growing transcript, is the same everywhere a conversation gets compacted or summarized.