Claude Code resume: treat sessions like save files, not lost work

The laptop rebooted for an update at eleven. This morning the terminal is empty, and you are typing the paragraph you already typed yesterday: the architecture, the constraint about the auth module, the two approaches that already failed. Twenty minutes of re-briefing an agent that knew all of it at dinner time.

Here is the part that stings: nothing was lost. Claude Code writes every conversation to disk continuously, without being asked. The session that died with your terminal is sitting in a folder, waiting. The blank prompt is not a fact of agent life. It is a default you never questioned.

Gamers figured out this relationship decades ago: play dangerously, save often, reload without shame. Your sessions already behave like save files. This post is about treating them that way.

Three ways back into a Claude Code session

claude --continue reopens the most recent session in the current directory: the whole conversation, tool calls and results included. Closed the terminal mid-task, rebooted, came back after lunch: one flag and the agent is mid-thought again.

claude --resume opens a picker listing every saved session for the project, searchable, with previews. Useful the moment "the most recent one" is not the one you want.

claude --resume <name> skips the picker, which is why the most underrated habit here is naming. Run /rename payment-refactor in any session that might outlive the terminal, and it becomes addressable tomorrow. Unnamed saves all look alike in a list of twelve.

Sessions are stored per project directory, so each repo keeps its own history, and the official sessions docs cover the picker shortcuts and what a resumed session restores. The point to internalize is smaller than the docs: a closed terminal loses nothing. Ctrl-C, a crash, an update reboot: all of it is a pause, not an ending.

Rewind is loading an earlier save

Resume gets you back to the latest state. /rewind covers the other recovery: the session is alive, but the last forty minutes made everything worse.

Claude Code checkpoints your files before every prompt you send. Run /rewind (or press Esc twice on an empty prompt) and you get a menu of those prompts; pick one and restore the code, the conversation, or both. Wrong turn at prompt fourteen? Load the save from prompt thirteen, rewrite the instruction that sent it sideways, and play the run again. The checkpointing docs list what the menu can do, including summarize options for trimming a bloated session in place.

Checkpoints travel with the session, so yesterday's resumed conversation can still rewind yesterday's mistakes.

And when you want both timelines, /branch (or claude --continue --fork-session) is a new save slot: copy the conversation so far, try the risky approach in the copy, and keep the original untouched in the picker in case the experiment dies.

Resume or start fresh: the actual decision

Recovery being possible does not make it always right. The rule that holds up: resume interrupted work, start fresh for new work.

Resume when the session holds state that was expensive to build and the task is genuinely unfinished: a half-done investigation, a refactor with hard-won constraints negotiated along the way, anything you would have to re-explain for twenty minutes.

Start fresh when the last task is done and a new one begins. A long session accumulates noise that quietly degrades the agent, and dragging one conversation across three tasks buys you drift, not continuity. Start fresh, too, when the session itself is the problem: an agent circling the same failed fix does not need its rut lovingly restored. Reloading a poisoned save just replays the poison.

What the save system cannot give back

The honest section, because recovery has edges:

• Rewind restores edits, not consequences. Checkpoints track file edits made through Claude's editing tools. Files a shell command deleted, a migration that ran, packages that installed: none of it reverts. Git stays the real undo, which is a reason to commit before handover.
• Resume restores the transcript, not the world. The dev server it started, background jobs, shell state: gone. The agent may believe things are running that are not; expect one confused minute.
• Old, huge sessions resume with a toll. Return to a 100k-token conversation after an hour away and you choose between a summary (cheaper, lossy) and the full history (every detail, heavier requests). Neither option is free, which is one more reason not to let sessions grow monstrous in the first place.
• Save files become a crutch. If losing a session would lose the task, the task is stored in the wrong place. The brief belongs outside the conversation, where any fresh session can pick it up.

Save files for the chat, a board for the work

That last cost is the one SanuDesk exists to remove. It is a desktop app that tiles your Claude Code, Codex and Gemini sessions into one grid, next to a Kanban board that holds the actual work: each task is a card with its brief and acceptance criteria, and deploying the card opens a fresh session already briefed. When the agent stops, the card parks in a review lane with a note on what changed.

That splits recovery cleanly in two. Resume and rewind rescue conversations, and the board makes rescue optional: kill any session, deploy the card again, and nothing about the task is lost, because the task never lived in a scrollback. Recurring work becomes Loops that run on a schedule and journal every run. It is bring-your-own-model, driving the agent subscriptions you already pay for, and the grid and board are in the free plan (details on pricing).

Sessions stay disposable. Work stays durable. That is the whole trick.

Run the fire drill

Do the drill before you need it, it takes five minutes. Open a project, run claude --resume, and read the picker: that is your save library, probably fuller than you expected. Rename the session you are in. Then, on your next real task, stop once at a bad moment on purpose, close the terminal, and bring it back with claude --continue.

Once you have watched a dead terminal come back mid-thought, you stop hoarding sessions and start playing dangerously, which is where agents earn their keep.

Download SanuDesk free to give the rescued sessions a grid and the work a board, or see how the pieces fit on the features page.