Claude Code: how to continue your last session

Run claude --continue, or claude -c for short, and Claude Code drops you straight back into the most recent session for the directory you are in. No picker, no session id, no scrolling. That is the whole answer, and for the common case (you closed the terminal, you want the thread back) it is the only command you need. The rest of this post is the three things that trip people up: how it differs from --resume, why the directory matters more than the timestamp, and when you should fork rather than continue.

--continue or --resume: which one you want

They sound like synonyms and they are not. One assumes it knows which session you mean, the other asks:

The directory decides what you continue

This is the one real gotcha, and it explains almost every "it continued the wrong conversation" report. --continue is scoped to the directory you launch it from, not to your machine and not to the clock. The most recent session in ~/code/api and the most recent session in ~/code/web are two different sessions, and -c gives you whichever belongs to where you are standing. Sessions you pulled in with /add-dir count as part of that directory too.

Git worktrees make this sharper than people expect. Two worktrees of the same repo are two different paths, so they hold two different session lists. Continue from the wrong worktree and you get a genuinely different conversation, not an empty one, which is far more confusing. If -c hands you something unfamiliar, check pwd before you check anything else.

Fork when you want to try something without spending the thread

claude --continue --fork-session reopens the same conversation but writes it forward under a new session id, leaving the original untouched. It is the cheap answer to "I want to try a risky direction from here." Continue normally and the detour is now part of the only copy you have. Fork and the thread you liked is still sitting there to go back to. The same flag works with --resume.

Before you continue a long one, check what you are dragging with you

Continuing is not free. You are not just getting the conversation back, you are getting its whole context back, including everything that made it slow the first time. Three quick checks:

1. If it was already slow, do not continue it. A session that crawled at the end will crawl from the first message when you reopen it, because the thing that slowed it down was its own size. Start fresh and paste in the two facts that matter.
2. If it ended right after a compaction, expect a summary, not a transcript. /compact replaces the conversation with a structured summary and stays in the same session. Continue it and you inherit the summary, so anything the summariser dropped is gone from context even though it is still in the file.
3. If you only need one fact from it, do not reopen it at all. Continuing to retrieve one decision costs you the entire context window of that old session. Go read the transcript instead, or better, keep the decision somewhere that is not a transcript.

Continuing restores the words, not the plan

Here is what -c cannot do. It gives you back every message, which sounds like everything and is not. What you actually want when you sit down again is the short version: what am I building, which step am I on, what did we decide last time and why. That is three lines. Continuing a session hands you three hundred messages and asks you to reconstruct those three lines yourself, and so does the agent.

So the kit writes the three lines down as it goes. Our /step and /start skills update lastSession.note in .kitstarter/journey.json with a one-line human summary before they finish ("finished the booking page skeleton"), and the SessionStart hook prints it back at you the next time you open the project: a progress bar, the step you are on, and a Last time: line. It costs one line of context instead of an entire window, it works in a fresh session, and it does not care whether you continued, resumed, or started over.

The rule of thumb: continue when the thread is short and recent, start fresh when it is long, and keep the plan somewhere a picker cannot lose it. That last part is what kitstarter does by default. Worth reading next: how to see every session you have when `-c` gives you the wrong one, and what a full context window really costs you when you reopen a big session.

Common questions

How do I continue my last Claude Code session? Run claude --continue, or claude -c for short. It reopens the most recent session for the directory you are in, with no picker and no session id. If the one you want is not the most recent, use claude --resume instead and pick it from the list.

What is the difference between claude --continue and claude --resume? --continue assumes it knows which session you mean and reopens the most recent one for the current directory. --resume asks: it opens an interactive picker so you choose. Use continue when you just closed the terminal, resume when the one you want is further back.

Why did claude -c continue the wrong conversation? Almost always because you launched it from a different directory. Sessions are scoped to the folder you start in, so the most recent session in one project is not the most recent session in another. Git worktrees count as different paths too. Check pwd first.

Can I continue a Claude Code session in a script? Yes. Combine continue with print mode: claude -c -p "your prompt" resumes the last session for that directory, sends one prompt, and returns the answer without an interactive terminal.