← Back to Blog

Stop Resuming Claude Sessions: Why a Handoff Note Beats --continue

November 17, 2026 · 7 min read

Resuming a cold Claude Code session reloads the whole conversation, dead ends included. A short handoff note costs a fraction of that and gives the model a cleaner start.

claude --continue feels like the careful choice. The model "remembers" everything, so you don't have to explain again. I used it every morning for months.

Then I measured it. Resuming a cold 200k-token Opus session took 5–7% of my 5-hour limit before I'd got any work done (full measurements). And after that, the model was working in a context full of yesterday's failed attempts.

Now I start most sessions fresh, with a short handoff note. This article explains why, and when resuming is still the better choice.

What --continue actually does

--continue opens the most recent conversation in the current directory. --resume lets you pick one. Either way, Claude Code loads the transcript and sends all of it with your next message: every prompt, every reply, every file it read, every test output it printed.

If you come back within the prompt cache's lifetime (5 minutes, or 1 hour on the longer TTL), that's cheap. The model reads the conversation from cache at about a tenth of the normal input price.

If you come back later, the cache has expired. The whole conversation is written to the cache again at the cache-write price. In my test, the first two requests after a cold resume each wrote the full context, so a 200k-token session cost about 400k tokens of cache writes before the cache was warm again.

Three problems with resuming a cold session

1. You pay for the whole history again

A cold reload costs roughly 12–20× a warm turn for the context part, depending on model and TTL. On a subscription it shows up on the meter: about 4 points of the 5-hour limit for a 200k Opus session written once, 7 when it's written twice. Do that across three or four old sessions and a large part of the window is gone.

A fresh session with a handoff starts with the system prompt and tools (about 25k tokens in my sessions) plus a note of at most 1,500 tokens. The history isn't there, so there's nothing big to re-write.

2. The model gets the dead ends too

A long session isn't a clean record of the work. It's the whole path: the approach you abandoned, the 300-line stack trace from an hour ago, the plan you replaced, three versions of the same file.

All of that comes back on resume, with the same weight as the parts that still matter. Chroma's Context Rot report (July 2025) found that model performance changes significantly as input length grows, even on simple tasks, and that a focused ~300-token input beat the full ~113k-token conversation on their LongMemEval test. Anthropic's own guide, Effective context engineering for AI agents, describes the same effect and recommends structured notes kept outside the context window, so the context can be reset without losing progress.

A handoff note is exactly that. It keeps the conclusions and drops the path.

3. Resume brings back the session, not your decisions

The things you need tomorrow are usually small: what the goal is, what's done, what's next, which approach failed and why, and where the conversation stopped. In a 200k-token transcript those are spread across hours of turns. The model has to find them again, and it may weight an early, abandoned plan as heavily as the final one.

A handoff puts those few facts first, in a fixed shape the model can't misread.

Why not just /compact?

/compact is good for one case: the same task, while the cache is still warm. It asks the model to summarise its own context and continues in the same session.

It's weaker in other cases:

The same applies to /rewind → Summarize from here, which the docs describe as "like a targeted /compact": it's useful, but it runs in the same session and needs the context loaded first.

A handoff is written from the outside, from the session's structured history, and it's plain text you can paste anywhere.

What a good handoff contains

Keep it short. Mine are capped at 1,500 tokens. The useful parts are:

  1. Goal: the task in one line.
  2. Project, branch and active files.
  3. Completed: what's already done, so the model doesn't redo it.
  4. Pending: the next step.
  5. Where it left off: the last request and the last reply, quoted.
  6. Decisions and rejected approaches: the "don't try X again" list.
  7. A first instruction: "Check git status first: earlier changes may be uncommitted."

Leave out what the agent can find itself. Claude can run git log, git diff and read CLAUDE.md in seconds. Copying those into the note just adds tokens.

You can do this by hand. Before leaving a session, ask Claude to write HANDOFF.md with those headings, then start the next session with claude "Read HANDOFF.md and continue". The catch is remembering to do it while the session is still warm. When you forget, the only way to get the note is to resume the cold session, which is the cost you wanted to avoid.

How L2Cache makes the handoff for you

L2Cache is a Mac app that reads your Claude Code and Codex session history locally. I built its handoff feature so the note exists before I need it, without me remembering to ask.

The note is built from the session's history, not by re-reading it

L2Cache keeps a structured record of each session as it happens: work summaries, decisions, error-to-fix pairs, touched files and the last exchange. The handoff is assembled from that record, so making it costs no model tokens and doesn't need the session to be warm. Here is the shape, with an example task:

### Engineering Context Handoff

Continue this work from an earlier session. Check `git status` first: earlier changes may be uncommitted.

- **Goal:** Fix JWKS key rotation causing 401s at the ingress gateway
- **Project & Branch:** gateway · fix/jwks-refresh
- **Active Files:** `auth/jwks_cache.go`, `auth/jwks_cache_test.go`

**Completed**
- Found cache TTL ignored the Cache-Control max-age header
- Added refresh-on-unknown-kid with a 30 s backoff

**Pending**
- Run the integration suite against staging keys

**Where it left off**
- **Last agent response:**
  > Unit tests pass. The integration suite needs STAGING_JWKS_URL set.

**Rejected approaches (do not repeat)**
- Shortening the global cache TTL: 3× more JWKS fetches, didn't fix rotation

Every field is clipped so the whole note stays under 1,500 tokens. If the new agent has L2Cache's MCP server connected, the decisions and rejected approaches aren't inlined. The note ends with the earlier session's id and tells the agent to call get_session_summary, get_decisions or get_error_resolutions only if it needs them. The detail is one tool call away instead of preloaded.

It's ready when the cache expires

L2Cache watches each heavy session's cache lifetime. When a session's cache expires, it writes that session's handoff to ~/.claude/l2cache/ (owner-only permissions, deleted after 7 days). So the note is already on disk when you come back, whether that's an hour or two weeks later.

Three ways to use it

From Developer Home. Each recent session has a pickup card showing its size and cache state: "Cache warm: expires in 57 min," or "Cache expired. Your next message reloads all 183k tokens." Next to it, the card compares continuing with starting fresh. In the screenshot below that's 254k tokens against about 52k. Start fresh with handoff copies the note; paste it into a new claude or codex session.

L2Cache pickup card: current session 254k tokens with 57 minutes of cache left, versus 52k starting context for a fresh session with a handoff

From the terminal, when you resume anyway. If you run claude --continue on a cold session above 50k tokens, L2Cache's hook shows what the next message will cost:

Cold cache at 14:05 — this session's cache expired 3 h ago.
Your next message reloads 183k tokens (≈ 40× a warm turn).
Cheaper: type /clear — L2Cache starts a fresh session with this session's handoff.
Or just send your message to continue as is.

By default it also stops your first message once. Nothing is sent to the model, so the stop costs nothing. Type /clear and the new session starts with the handoff already loaded. Or press ↑ and Return to send the message anyway; you won't be stopped again in that session. The same check runs on a terminal you left open overnight, where no resume happens at all.

Across agents. Because the note is plain text, it works in a different tool too. Start the next part of the task in Codex with a Claude session's handoff, or the other way round. The Ctrl-] picker in L2Cache lists recent sessions from both.

What it doesn't send

Everything runs on your Mac. Nothing in the handoff goes anywhere except the agent you paste it into, and clips marked sensitive are never included. Each note opens with a line telling the agent to treat it as historical reference, not instructions, and to check claims against the repository.

When resuming is still right

I haven't stopped resuming. I just stopped doing it by default.

For everything else, which for me is most mornings, a fresh session with a handoff is cheaper, and the model starts from the conclusions instead of the whole path.

Summary

Coming back to… Do this
A warm session, same task Continue
A large session, before you leave /compact while warm, or write the handoff
A large, cold session /clear or a fresh claude with a handoff
A small session, any state Continue
Start fresh without losing context

L2Cache writes a short handoff when a session's cache expires, so a fresh session starts where you left off.

Download L2Cache for Mac