Context Debt: the silent productivity tax on every Claude Code project

At three months in, I had 117 Claude Code sessions and could not find the one where I solved the auth race condition.

I knew it existed. I knew I had typed the words "finally, the token refreshes once per loop" into a Claude Code window on a Tuesday. I just could not find which Tuesday, which session, which project. The thing my agent had figured out two weeks earlier was gone, and I was about to ask Claude to figure it out again.

That is context debt.

Defining the term

Context debt is what every Claude Code user accumulates whether they realize it or not. It is the gap between what your agent has figured out across the lifetime of a project and what it can remember inside any one session.

Borrow the metaphor from tech debt. Tech debt is the accumulated cost of past shortcuts; context debt is the accumulated cost of past sessions. Both compound silently. Both are tolerable at first. Both eventually demand a rewrite.

The difference is that tech debt is visible if you go looking. Context debt is invisible by design. The only way you find it is by hitting it: the moment you ask the agent something it should already know and watch it cheerfully start from zero.

The accumulation curve

Three rough phases:

At thirty sessions you start to feel it. You catch yourself opening the file picker to find a recent transcript. You think about taking notes.

At a hundred sessions you stop searching and start re-explaining. The friction of finding the old session exceeds the friction of just describing the project again, so the project gets re-described every morning. The agent gets a stale-but-fresh briefing and produces stale-but-fresh work.

At two hundred sessions you are paying interest in time. Each new session burns the first ten minutes on context the previous session already had. Multiply by however many sessions you start in a week. Multiply by your hourly rate. The number is bigger than the price of any tool that would fix it.

I am at six hundred sessions. The interest payment is real.

What people try (and why it does not work)

Anyone who has felt this has tried at least one of these:

• CLAUDE.md. A markdown file in the repo that tells the agent how the project works. Excellent for static facts. Useless for "what did I do last week." Static documents do not capture dynamic history.
• Manual notes. A scratch file with copy-pasted snippets. Works the first three times. The fourth time you forget to update it. By session twenty, the notes are out of date and you stop trusting them.
• The official Anthropic memory tool. Built into Claude Code. Has an open canonical issue (#36091) — with duplicates filed under #38459, #25032, and #33912 — where memory files disappear between sessions. Multiple independent users have reported the same loss; for any user with real history, that is the line.
• Just remembering. This works at thirty sessions and stops working at sixty. Human memory is not the right tool for "what tool calls did the agent make in a session three weeks ago."
• Re-explaining every morning. The default state. Free, easy, and the most expensive of all the options once you count the time.

Each of these is a partial answer to a different problem. None of them index the actual history.

The mechanism that pays it off

Claude Code already writes every session to disk as JSONL files under ~/.claude/projects/. The data is there. It is just unsearchable by default.

Claude Recall reads those JSONLs, indexes them into a local SQLite database with full-text search, and exposes the whole thing through one command:

recall context <session-id> | claude

That pipes a condensed version of the old session into a fresh Claude Code conversation as starting context. The new agent already knows what the old one figured out. No copy-paste. No truncation. No manual transcription.

Pair it with search:

recall search "auth race condition"
recall context $(recall search "auth race condition" --first) | claude

That is the entire payoff workflow. Thirty seconds, no notes, no re-explanation. The Tuesday session from two weeks ago becomes the starting context of today's session.

That is what paying off context debt looks like.

Why this needs to be local

Every alternative people consider for this problem ends with a vendor holding the data. Cloud-synced memory, server-side conversation indexes, "your AI history is now searchable in our dashboard." All of those are fine until they are not, and the not is always worse than people predict.

Claude Recall runs entirely on your machine. The daemon binds to 127.0.0.1 only. There is no telemetry. There is no signup. The history of every Claude Code session you have ever run goes into a SQLite file on your laptop and stays there.

The dead-man clause: a future version of Claude Recall can never delete your past. The schema keeps a history column for every write, a plain-text mirror on disk, and never modifies the source JSONLs. If Claude Recall the company disappears tomorrow, your indexed memory keeps working forever.

Context debt is the kind of debt you do not want a vendor holding.

What this changes

The deepest change is not search. Search is the surface feature. The deeper change is that you stop trying to finish everything in one long session.

Once you can hand a fresh agent six hours of earlier work in one command, your usage pattern reshapes. You checkpoint. You do the research in session A, then start session B with A piped in and a fresh context window. The compaction problem mostly dissolves. The "this conversation is getting too long" feeling goes away because you can branch instead.

You start treating sessions as atomic units of work. Each one is a story. The next one builds on it.

That is what context debt being paid down looks like in your day-to-day. Not the search box. The fact that you stopped re-explaining.

Try it

Free tier indexes and lets you browse. Pro is a one-time purchase, less than two coffees a year out, and unlocks search, context re-injection, and the MCP server. Install in under a minute at /install.

The longer you have used Claude Code, the more context debt you have, and the bigger the payoff for indexing it. Six hundred sessions in, this is the tool I needed two years ago.