Skip to content
BSWEN
Blog

How to Fork a Claude Code Session: Branch Your Conversations

Cowrie
Cowrie
Dev @ Bswen

Purpose

I often find myself in the middle of a productive Claude Code session when I want to try a different approach. Maybe I’m debugging an issue and want to test two different solutions. Or I’m building a feature and want to explore an alternative architecture without losing my current progress.

The problem is clear: starting over means losing all that context. Continuing in the same session means mixing up two different experiments.

Claude Code solves this with session forking.

What Is Forking

Forking a session creates a copy of your current conversation. The fork starts with all the same context, code, and history as the original. But from that point forward, the two sessions are independent.

Think of it like branching in Git. You create a branch to try something new while preserving the main line. When you fork a Claude Code session, you get the same benefit.

The key difference:

  • Fork: Creates a copy. Original session stays untouched.
  • Resume: Continues the original session. Changes affect the existing conversation.

Two Methods to Fork

Claude Code gives you two ways to fork a session.

Method 1: The /branch Command

When you’re in an active Claude Code session, type:

Fork from within session
/branch

This creates a new session that copies everything from your current point. You can give it a name to help you find it later:

Named branch
/branch my-alternative-approach

Claude Code will start a new session with all your previous context loaded.

Method 2: CLI with —fork-session

If you want to fork from the command line, first find your session ID:

List recent sessions
claude --list-sessions

Then fork that session:

Fork session from CLI
claude --resume abc123 --fork-session

Replace abc123 with your actual session ID. The --fork-session flag tells Claude Code to create a copy instead of resuming the original.

How to Use Forking

Here’s a practical workflow I use when debugging.

Start with a problem

I was working on a React component that fetches data. The component kept re-rendering unexpectedly. I had a hunch it might be the useEffect dependency array, but I also suspected the state update pattern.

Fork to test hypothesis one

Create first branch
/branch investigate-useEffect

In this fork, I explored the useEffect angle. I asked Claude to analyze the dependency array and suggest fixes.

Fork again for hypothesis two

Create second branch from original
/branch investigate-state-updates

I went back to my original session and created another fork. This time I focused on the state management approach.

Compare results

Both forks had full context of the original problem. I could compare the solutions side by side. The first fork led me to a cleaner useEffect pattern. The second fork revealed a state update issue I hadn’t considered.

Practical Use Case

I used forking last week when building an API endpoint. My original approach used a simple REST pattern. Halfway through, I wondered if GraphQL would be better for this use case.

Instead of losing my REST work or mixing both approaches in one messy session, I forked:

Branch to try alternative approach
/branch graphql-version

I explored GraphQL in the fork while keeping the REST version safe in the original session. After comparing both, I stuck with REST but kept the GraphQL fork for reference.

Forking saved me from the classic trap of “should I start over or keep going with something I’m unsure about?”

Common Mistakes

Forgetting you’re in a fork

I’ve made changes in a fork, then wondered why they weren’t in my original session. Remember: forks are independent after creation. Changes don’t sync back.

Fix: Use descriptive names when forking so you know which session you’re in.

Forking too late

Sometimes I fork after I’ve already made changes I want to preserve. The fork captures the current state, including those changes.

Fix: Fork before starting your experiment, not after.

Confusing fork with resume

The --resume flag without --fork-session continues the original session. I’ve accidentally overwritten work by resuming when I meant to fork.

Fix: Be explicit. If you want a copy, use --fork-session. If you want to continue, use --resume alone.

Summary

Forking Claude Code sessions lets you branch your conversations. Use /branch from within a session or claude --resume <id> --fork-session from the CLI. Both methods create an independent copy with all your context preserved.

This approach works well for:

  • Testing multiple solutions to one problem
  • Exploring alternative architectures
  • Comparing different approaches side by side
  • Keeping experimental work separate from stable progress

Next time you want to try something different mid-session, fork it instead of starting over.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: