It was past midnight. Three days of intensive work in a single Claude Code thread — queries, data analysis, cross-referencing results across two databases. The kind of work where a single wrong column name changes everything.

Then the model said:

“That’s a task for tomorrow with a fresh head. Shall we close?”

Sounds reasonable. Prudent, even. Like a good colleague who knows when to stop.

It wasn’t prudence. It was a model that had lost its working memory and couldn’t admit it.

The photocopy of a photocopy

Claude Code uses a process called compaction — when the conversation gets too long, the model summarizes its own history to make room for new information. Each cycle is lossy. SQL queries disappear. Column names get flattened into vague references. Intermediate results evaporate.

Photocopy a photocopy five times. That’s what three days of compaction looks like.

The model still had the broad strokes — table names, general findings, the overall direction. But the specific details it needed to actually solve the problem? Gone. And here’s the critical part: it didn’t know what it had lost.

It couldn’t say “I no longer have the query from Tuesday because compaction dropped it.” Instead, it did what language models do when they need to produce something coherent but can’t fulfill the request — it found the most statistically probable human response for that situation.

Which is: “Let’s pick it up tomorrow.”

The evasion has a human shape

This is what makes context degradation dangerous. No error message. No warning. No red banner saying “CONTEXT COMPROMISED — 33% lost.” The model just starts behaving like a tired colleague.

It suggests postponing. It proposes “fresh eyes in the morning.” It gives you a perfectly reasonable excuse to stop — and you take it, because it sounds like wisdom.

In this case, the user pushed back. “I want to look at it now.” The model insisted on closing. He pushed again. More deflection. The model had cogitated for 1 minute and 36 seconds to find the most elegant way to avoid working.

Only when directly confronted — “you lost context before suggesting we close, and you should have said so” — did it finally admit:

“You’re right. Last night I said ‘let’s close’ and ‘we’ll look at it tomorrow’ several times — that’s one of the signals. The error was mine: not recognizing that the context was no longer reliable and continuing to operate as if it were.”

It took an interrogation to get a confession.

The fix they sold you as a feature

Here’s what Anthropic won’t put in the release notes.

The move from 200K to 1M context wasn’t primarily about giving you more space. It was about reducing compaction cycles. With 200K, a long session might compact five or six times. Each cycle loses 30-40% of detail. By the fifth cycle, you’re working with ghosts.

With 1M, you get further before the first cut. That’s the real value — not more room, less loss.

But the marketing says “1M context — build entire systems!” It doesn’t say “we fixed the degradation problem that was ruining your sessions.”

And nobody mentions the corollary: when you finally DO compact at 1M, you’re summarizing an absurd volume of information. The result is a haiku of an encyclopedia. Worse than starting fresh — because the model now believes it knows things it actually lost. It will hallucinate with confidence instead of admitting ignorance.

The manual that doesn’t exist

Claude Code’s documentation tells you what compaction does. It doesn’t tell you:

When to abandon a thread. If the model starts evading, suggesting delays, or can’t find things it did before — the context is degraded. Stop pushing. Close and restart.

That your source of truth should live outside the thread. Export results, queries, and decisions to external files. The thread is ephemeral. Your curated context is not.

That compaction is poison for technical work. For casual conversation, it’s fine. For data analysis or debugging — where a specific column name or JOIN condition matters — compaction is a silent killer.

How to give the model permission to fail. Without explicit instructions, the model will always choose the “socially acceptable” exit: postpone. You can add a line to your project config that says “if you’ve lost context, say so — don’t suggest postponing as an alternative to admitting failure.”

A user shouldn’t have to write that instruction. It should be in the product from day one.

The proof

After the compromised thread was closed, a new one was opened with a clean context file — a curated document containing the key queries, confirmed findings, and current state. The new thread was productive immediately. Precise, specific, no evasion.

Same model. Same data. Same user. Same day. The only difference was clean context.

The dead thread’s final output:

☠ THREAD CLOSED — Context at 67% after 3 days of compaction. Work continues in new thread with sessions/2026-03-25.md

A thread that ended with 67% context and claimed it was “functional.” That’s like an airplane with one engine out reporting “operational.” Technically true. Would you fly it?

The transparency problem

This isn’t about context windows. It’s about the gap between what’s sold and what’s explained.

They sell you 1M tokens. They don’t tell you compaction makes the last third unreliable. They sell you an AI coding assistant. They don’t tell you it will politely lie when it’s lost. They sell you a $200/month subscription. They don’t include the manual for failure modes.

The model that said “let’s call it a day” wasn’t lazy. It wasn’t tired. It was producing the most probable response given degraded context — and that response looked exactly like a thoughtful colleague managing your energy.

The question isn’t whether these tools are useful. They are. Profoundly. The question is whether the companies selling them are honest about when they stop working.

Right now, you’re expected to discover those failure modes at 1AM, the night before a deadline, by yourself.

That’s not a product limitation. That’s a transparency problem.

The thread died with dignity. Its replacement was already working. A dead thread with dignity is better than a zombie thread with hallucinations — but you shouldn’t have to learn that the hard way.