Claude Code Checkpoints for Client Work: Undo a Bad Edit Before the Client Ever Sees It

What a Checkpoint Actually Is

A checkpoint is a restore point Claude Code creates automatically at each prompt you send. Before Claude edits a file, it snapshots the file first, so the checkpoint has something to revert to. You do not have to turn this on or remember to save anything. It happens on every prompt, in the background, for the length of the session.

This is separate from git. A checkpoint is not a commit, it does not show up in the client's repo history, and it does not replace the discipline of committing your own work at sensible points. It solves a narrower, more immediate problem: the few minutes right after an edit goes wrong, before you have had time to think about git at all.

Two Ways to Open the Rewind Menu

Press Esc twice when the prompt input is empty, or type /rewind, and Claude Code opens a scrollable list of your prompts from the current session. Pick the one you want to go back to.

On a paid client session, 'restore code' is usually the one you reach for: you want the file back the way it was before the bad edit, but you do not want to lose the conversation that got you there, including whatever the client already said about what they wanted.

What Checkpoints Do Not Cover

Checkpoints only track edits made through Claude's own file editing tools. If Claude runs a bash command that touches the filesystem directly, like rm, mv, or cp, that change is not tracked and a rewind will not undo it. The same is true for anything Claude does outside the repo entirely, like calling an API or writing to a database through an MCP connection.

A restore also skips symlinked or hard-linked files, and Claude Code will warn you when it has to skip something for that reason. If a client's project links a shared config or a vendored directory in from elsewhere, do not assume a checkpoint restore rolled that part back too.

Why This Matters More on Client Work Than on Your Own Projects

On your own codebase, a bad edit is annoying. On a client's codebase, a bad edit is billable time you cannot bill for, twice: once to make the mistake, once to fix it, and the client never sees either hour on the invoice. Checkpoints shrink that cost from however long it takes to manually reconstruct the working version, to the few seconds it takes to press Esc twice.

This pairs directly with running Claude Code in a higher-autonomy mode on client work. [Auto Mode](/blog/claude-code-auto-mode-for-client-work) approves more of Claude's own actions without asking you first, which is faster, but it also means more edits happen between the moments you are actually watching. Checkpoints are the reason that trade is safe to make: you are not giving up the ability to undo, you are just choosing to review after the fact instead of before.

A Checkpoint Habit for Client Sessions

1. Before a risky or large edit, note the last prompt you sent so you know exactly which checkpoint to reach for if it goes wrong.
2. Let Claude finish the edit, then actually look at the result before moving on to the next request. A checkpoint you do not know you need is a checkpoint you will not use in time.
3. If something is off, press Esc twice immediately rather than trying to prompt your way back to the original state. A second wrong edit on top of the first one makes the eventual restore messier.
4. Once you are back to a known-good state, commit it in git if it is a meaningful milestone. Checkpoints protect the session; commits protect the project.

The habit costs nothing extra day to day. It only pays off on the session where an edit goes sideways, which is exactly the session where you do not want to be improvising.

Checkpoints vs Git vs a Manual Backup

Checkpoints are the fastest of the three and the only one that requires zero setup, which is why they are useful for the in-session, five-minutes-ago kind of mistake. They are not a reason to commit less often to git on a client's repo.

Common Mistakes

1. Assuming a checkpoint restore also undoes a bash command Claude ran, like a delete or a move, when only edits through Claude's file tools are tracked.
2. Pressing a single Esc when you meant double-Esc, which redirects the current task instead of opening the rewind menu.
3. Not committing to git because checkpoints feel like enough of a safety net on their own, then losing the ability to roll back once the session that created them is gone.
4. Restoring 'both' out of habit when 'restore code' would have kept a conversation with useful client context intact.

Inside the Claude Code Profit Room, builders compare the actual moments a checkpoint saved a client session, and the ones where it did not, because the damage happened outside what Claude's file tools track. It's $9 a month at https://www.skool.com/claudecodeprofitroom/about, come tell us about the edit you wish you had caught sooner.