Worktrees vs stashing decision in Git - Visual Side-by-Side Comparison

Process Flow - Worktrees vs stashing decision

Start with changes in current branch

↓

Need to switch branch?

Yes↓

Are changes ready to save temporarily?

No→Use Worktree

Yes↓

Use Stash to save changes

↓

Switch branch

↓

Apply stash or continue worktree

This flow helps decide whether to use git stash or git worktree when switching branches with uncommitted changes.

Execution Sample

Git

git stash
# save changes temporarily

git checkout feature-branch
# switch branch

git stash pop
# apply saved changes

This sequence saves changes with stash, switches branch, then reapplies changes.

Process Table

Step	Action	State Before	State After	Notes
1	Modify files in current branch	Clean working directory	Uncommitted changes present	Working directory now dirty
2	Decide to switch branch	Uncommitted changes present	Decision point	Need to save or isolate changes
3	Use 'git stash'	Uncommitted changes present	Clean working directory, stash saved	Changes saved in stash stack
4	Switch branch with 'git checkout feature-branch'	Clean working directory	On feature-branch, clean working directory	Branch switched successfully
5	Apply stash with 'git stash pop'	Clean working directory, stash saved	Uncommitted changes reapplied, stash removed	Changes restored on new branch
6	Work continues on feature-branch	Uncommitted changes present	Uncommitted changes present	Ready to commit or modify further
7	Alternative: Use 'git worktree add ../feature feature-branch'	Uncommitted changes present	New worktree created with feature-branch checked out	Changes isolated in separate directory
8	Work independently in new worktree	Separate directory with feature-branch	Changes independent from main worktree	No stash needed, parallel work possible
9	Exit	Worktrees or stash used appropriately	Working directory state managed	Decision made based on workflow needs

💡 Execution stops after changes are saved either by stash or isolated by worktree, enabling branch switch or parallel work.

Status Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	After Step 5	After Step 7
Working Directory	Clean	Dirty (uncommitted changes)	Clean (changes stashed)	Clean (on new branch)	Dirty (changes reapplied)	Dirty (original worktree)
Current Branch	main	main	main	feature-branch	feature-branch	main
Stash Stack	Empty	Empty	1 stash entry	1 stash entry	Empty (stash popped)	Empty
Worktrees	1 (main)	1 (main)	1 (main)	1 (feature-branch)	1 (feature-branch)	2 (main + feature)

Key Moments - 3 Insights

Why do we need to stash changes before switching branches?

Because git won't let you switch branches if you have uncommitted changes that conflict. Stashing saves them temporarily (see execution_table step 3).

When is using a worktree better than stashing?

When you want to work on multiple branches at the same time without switching or losing changes. Worktrees create separate folders for each branch (see execution_table step 7).

What happens to the stash after 'git stash pop'?

The stash is applied to the working directory and then removed from the stash stack (see execution_table step 5).

Visual Quiz - 3 Questions

Look at the execution table, what is the state of the working directory after step 3?

A Dirty, changes still present

B Clean, no changes saved

C Clean, changes saved in stash

D Dirty, changes lost

💡 Hint

Check the 'State After' column for step 3 in the execution_table.

At which step does the branch actually switch to 'feature-branch'?

A Step 2

B Step 4

C Step 5

D Step 7

💡 Hint

Look for the action 'git checkout feature-branch' in the execution_table.

If you want to work on two branches simultaneously without switching, which step shows the best approach?

A Step 7 (create worktree)

B Step 5 (apply stash)

C Step 3 (stash changes)

D Step 4 (switch branch)

💡 Hint

Refer to the notes about worktrees in the execution_table at step 7.

Concept Snapshot

Git stash saves uncommitted changes temporarily to switch branches safely.
Git worktree creates separate folders to work on multiple branches simultaneously.
Use stash for quick save and switch.
Use worktree for parallel branch work.
Stash must be popped to restore changes.
Worktrees keep changes isolated without switching.

Full Transcript

This visual execution compares git stash and git worktree for managing uncommitted changes when switching branches. First, if you have changes and want to switch branches, git requires a clean working directory. You can save changes temporarily using 'git stash', which cleans your directory and stores changes safely. Then you switch branches with 'git checkout' and reapply changes with 'git stash pop'. Alternatively, you can create a new worktree with 'git worktree add' to have a separate folder checked out to another branch. This allows working on multiple branches at once without switching or stashing. The execution table shows each step's state changes, including working directory status, current branch, stash stack, and worktrees. Key moments clarify why stashing is needed before switching, when worktrees are better, and what happens to stash after popping. The quiz tests understanding of working directory states, branch switching steps, and when to use worktrees. The snapshot summarizes the decision: stash for temporary save and switch, worktree for parallel work.