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.

Practice

1. What is the main purpose of git stash in Git?

easy

A. Create a new branch in a separate folder

B. Temporarily save changes and clean the working directory

C. Merge two branches automatically

D. Delete untracked files from the repository

Solution

1. Step 1: Understand what git stash does

   git stash saves your current changes temporarily and cleans your working directory so you can switch branches or work on something else without committing.

2. Step 2: Compare with other options

   Creating a new branch in a separate folder is done with worktrees, not stash. Merging branches and deleting untracked files are unrelated commands.

3. Final Answer:

   Temporarily save changes and clean the working directory -> Option B

4. Quick Check:

   Stash = Temporary save changes [OK]

Hint: Stash saves changes fast, worktrees create folders [OK]

Common Mistakes:

• Confusing stash with branch creation
• Thinking stash deletes files permanently
• Mixing stash with merge operations

2. Which command correctly creates a new worktree for branch feature in folder feature-folder?

easy

A. git worktree add feature-folder feature

B. git stash create feature-folder feature

C. git branch add feature-folder feature

D. git checkout -b feature feature-folder

Solution

1. Step 1: Recall the syntax for adding a worktree

   The correct syntax is git worktree add <path> <branch>. So git worktree add feature-folder feature creates a new folder with the branch checked out.

2. Step 2: Check other options for correctness

   git stash create is invalid for this purpose. git branch add is not a valid command. git checkout -b creates a branch but does not create a separate folder.

3. Final Answer:

   git worktree add feature-folder feature -> Option A

4. Quick Check:

   Worktree add = git worktree add [OK]

Hint: Worktree add uses: git worktree add folder branch [OK]

Common Mistakes:

• Using stash commands to create worktrees
• Confusing branch creation with worktree creation
• Incorrect order of arguments in commands

3. You have uncommitted changes on branch main. You want to switch to feature branch without losing changes. What happens if you run git stash then git checkout feature?

medium

A. Git throws an error and refuses to switch branches

B. Changes are lost permanently after checkout

C. Changes are saved temporarily, branch switches cleanly

D. Changes are automatically merged into feature branch

Solution

1. Step 1: Understand what git stash does before switching

   git stash saves your uncommitted changes safely and cleans your working directory so you can switch branches without conflicts.

2. Step 2: Effect of git checkout feature after stash

   Since the working directory is clean after stash, Git switches to feature branch without errors or losing changes. You can later apply the stash.

3. Final Answer:

   Changes are saved temporarily, branch switches cleanly -> Option C

4. Quick Check:

   Stash saves changes, checkout switches branch [OK]

Hint: Stash before checkout saves changes safely [OK]

Common Mistakes:

• Assuming changes are lost after stash
• Expecting automatic merge of stashed changes
• Thinking Git errors on switching with stash

4. You tried to create a worktree with git worktree add feature but got an error. What is the most likely cause?

medium

A. The folder name is missing, causing a syntax error

B. You have uncommitted changes that block worktree creation

C. The branch feature does not exist

D. You forgot to stash changes before adding worktree

Solution

1. Step 1: Check the command syntax

   git worktree add requires two arguments: folder path and branch name. The command git worktree add feature only has one argument, so it is missing the folder name.

2. Step 2: Understand error cause

   Missing folder argument causes Git to throw a syntax error. Uncommitted changes or branch existence issues cause different errors, but syntax error is most likely here.

3. Final Answer:

   The folder name is missing, causing a syntax error -> Option A

4. Quick Check:

   Worktree add needs folder and branch [OK]

Hint: Worktree add needs folder then branch [OK]

Common Mistakes:

• Ignoring missing folder argument
• Assuming uncommitted changes block worktree add
• Confusing stash necessity with worktree creation

5. You want to work on two branches, main and feature, simultaneously without committing unfinished work on main. Which approach is best?

hard

A. Use git stash to save changes on main and switch branches repeatedly

B. Delete the feature branch and work only on main

C. Commit unfinished work on main before switching to feature

D. Create a worktree for feature branch to work in a separate folder

Solution

1. Step 1: Understand the need for parallel work

   You want to work on two branches at the same time without committing unfinished work on main. Stashing and switching repeatedly is slow and error-prone.

2. Step 2: Choose the best tool for parallel branch work

   Worktrees allow you to have multiple branches checked out in different folders simultaneously. This lets you work on main and feature side by side without switching or stashing.

3. Final Answer:

   Create a worktree for feature branch to work in a separate folder -> Option D

4. Quick Check:

   Worktrees = parallel branches in folders [OK]

Hint: Worktrees let you work on branches side-by-side [OK]

Common Mistakes:

• Using stash repeatedly instead of worktrees
• Committing unfinished work prematurely
• Deleting needed branches accidentally