You're working on a feature when your teammate reports a critical bug in production. You need to switch to the main branch to fix it immediately, but your current work is incomplete and not ready to commit.

Your task is to:

Stash your incomplete work
Switch to the main branch
Fix the urgent bug and commit it
Return to your feature branch
Restore your stashed changes
Complete your feature and commit it

Key Concepts

What is Git Stash?

Git stash temporarily saves your uncommitted changes (both staged and unstaged) and reverts your working directory to match the HEAD commit. Think of it as a clipboard for your changes.

When to Use Stash

Use stash when you need to:

Switch branches but have uncommitted changes
Pull updates from remote but have local modifications
Quickly test something on a clean working directory
Save work temporarily without creating a commit
Context-switch between tasks

Stash vs Commit

Stash:

Temporary storage
Not part of project history
Can be applied to different branches
Easy to discard if not needed
Local only (not pushed to remote)

Commit:

Permanent part of history
Creates a snapshot in the project timeline
Associated with a specific branch
Should be meaningful and complete
Can be pushed to remote

The Stash Stack

Git stash works like a stack (LIFO - Last In, First Out):

stash@{0}  <- Most recent stash (top of stack)
stash@{1}
stash@{2}  <- Oldest stash

You can have multiple stashes and apply any of them.

Useful Commands

# Stash current changes
git stash
git stash save "description"  # With a descriptive message

# Stash including untracked files
git stash -u

# List all stashes
git stash list

# Apply most recent stash and remove it from stack
git stash pop

# Apply most recent stash but keep it in stack
git stash apply

# Apply a specific stash
git stash apply stash@{1}

# Show what's in a stash
git stash show
git stash show -p  # Show full diff

# Drop (delete) a stash
git stash drop stash@{0}

# Clear all stashes
git stash clear

# Create a branch from a stash
git stash branch new-branch-name

Verification

Run the verification script to check your solution:

.\verify.ps1

The verification will check that:

The bug fix commit exists on main
Your feature is completed on the feature branch
Changes were properly stashed and restored
No uncommitted changes remain

Challenge Steps

Navigate to the challenge directory
You're on feature-login with uncommitted changes
Check status: git status (you'll see modified files)
Stash your changes: git stash save "WIP: login feature"
Verify working directory is clean: git status
Switch to main: git switch main
View the bug in app.js and fix it (remove the incorrect line)
Commit the fix: git add app.js && git commit -m "Fix critical security bug"
Switch back to feature: git switch feature-login
Restore your work: git stash pop
Complete the feature (the TODOs in login.js)
Commit your completed feature
Run verification

Tips

Always use git stash save "message" to describe what you're stashing
Use git stash list to see all your stashes
git stash pop applies and removes the stash (use this most often)
git stash apply keeps the stash (useful if you want to apply it to multiple branches)
Stashes are local - they don't get pushed to remote repositories
You can stash even if you have changes to different files
Stash before pulling to avoid merge conflicts
Use git stash show -p to preview what's in a stash before applying

Common Stash Scenarios

Scenario 1: Quick Branch Switch

# Working on feature, need to switch to main
git stash
git switch main
# Do work on main
git switch feature
git stash pop

Scenario 2: Pull with Local Changes

# You have local changes but need to pull
git stash
git pull
git stash pop
# Resolve any conflicts

Scenario 3: Experimental Changes

# Try something experimental
git stash  # Save current work
# Make experimental changes
# Decide you don't like it
git restore .  # Discard experiment
git stash pop  # Restore original work

Scenario 4: Apply to Multiple Branches

# Same fix needed on multiple branches
git stash
git switch branch1
git stash apply
git commit -am "Apply fix"
git switch branch2
git stash apply
git commit -am "Apply fix"
git stash drop  # Clean up when done

Stash Conflicts

If applying a stash causes conflicts:

Git will mark the conflicts in your files
Resolve conflicts manually (like merge conflicts)
Stage the resolved files: git add <file>
The stash is automatically dropped after successful pop
If you used apply, manually drop it: git stash drop

What You'll Learn

Git stash is an essential tool for managing context switches in your daily workflow. It lets you maintain a clean working directory while preserving incomplete work, making it easy to handle interruptions, urgent fixes, and quick branch switches. Mastering stash makes you more efficient and helps avoid the temptation to make "WIP" commits just to switch branches. Think of stash as your temporary workspace that follows you around.