Resume a session with --continue and --resume

It’s Monday morning. On Friday you’d gotten Claude Code deep into a refactor of the payments API — it knew the rate limiter belonged in its own middleware, it knew you’d decided against a Redis-backed store as too heavy, it knew which three approaches you’d already tried and thrown away. Then you closed the laptop for the weekend.

Now you’re staring at a fresh terminal, and all of that shared understanding is sitting on the wrong side of a closed session. The naïve move is to start typing and re-explain it — which is slow, and worse, you’ll re-explain it imperfectly and the agent will half-remember a version of Friday that never happened.

You don’t have to. Claude Code persists every session; Monday morning is just a matter of reopening Friday’s instead of starting over.

Picking the session back up

There are two ways in, and which you reach for depends on one thing: whether you already know which session you want.

claude --continue      # or -c — reopen the MOST RECENT session in this directory
claude --resume        # or -r — show a picker of past sessions, choose one

--continue is the one you’ll use most mornings: same project, straight back to the most recent thread. So from inside the API repo:

$ claude --continue

  ⎿ Resumed session from ~/code/payments-api (Fri 18:40)
    Last 40 messages restored.

> where did we leave the rate-limiter refactor?

  You'd pulled the limiter into src/middleware/rateLimit.ts and were about
  to wire it into the /login route. The Redis-backed store was ruled out as
  too heavy; we settled on an in-memory LRU. Want me to finish the wiring?

Notice what didn’t happen: the agent didn’t re-derive any of that. It read it straight back from the restored conversation. The Redis dead end you’d closed on Friday stays closed, instead of getting cheerfully re-proposed an hour into Monday.

--resume is for the mornings when the most recent session isn’t the one you want — you did a quick README fix after the refactor, and now --continue would drop you into that instead. The picker lets you reach past it:

$ claude --resume

  Select a session to resume:
    payments-api · README + contributing      Fri 19:10     8 msgs
  ❯ payments-api · rate-limiter refactor       Fri 18:40    40 msgs
    payments-api · fix flaky auth test         Thu 16:22    12 msgs

Already inside a session and realize you want a different one? /resume opens that same picker without making you quit first.

Two things that will trip you up

The first is scope. Sessions belong to the directory they ran in — --continue reopens the most recent session for the project you’re currently standing in. Run it from your home directory instead of the repo and you’ll either resume the wrong thread or none at all. cd into the project first; it’s a five-second habit that saves a confusing minute.

The second is subtler and more important: resuming restores the conversation, not the world. It brings back what was said on Friday — not the uncommitted edits, not the branch you had checked out, not anything you changed by hand over the weekend. If Friday-you left three files modified but unstaged and Saturday-you stashed them, Monday’s resumed session will happily talk about those changes as though they’re still there. Treat the code as whatever git status says right now; treat the conversation as a memory of intent, not a snapshot of the filesystem.

That second point is worth sitting with, because it draws the line this whole chapter lives on. Resuming is not the agent remembering you across time the way a colleague would — it’s replaying a saved transcript into a fresh window. Close that transcript without resuming it and the knowledge is genuinely gone. So anything you need to survive no matter which session you open — the test command, the conventions, the architectural call you keep having to restate — doesn’t belong in a chat you might or might not resume. It belongs in CLAUDE.md, where every future session reads it for free.

The flip side

Resuming is the cheapest context you’ll ever buy: a whole window’s worth of hard-won understanding, restored by a single flag. But the same power has a failure mode, and it’s the setup for the next lesson.

Because resuming is so easy, you’ll be tempted to do it out of habit even when the new task has nothing to do with the old one — drag Friday’s refactor into Monday’s unrelated bug fix just because the session is right there. That’s not continuity, that’s clutter. The discipline is to resume when you’re genuinely continuing, and to start clean when you’re not.

Which is exactly the situation that’s about to land on you — an unrelated bug, jumping the queue.