What is git stash and when do you use it?

Question

Accepted Answer

**git stash** temporarily **saves your uncommitted changes** and reverts your working directory to a clean state — so you can switch contexts (e.g. fix an urgent bug on another branch) without committing half-done work, then restore the changes later.

## The problem stash solves

```text
You're mid-work with uncommitted changes, but need to switch context urgently:
  → switch branches? Git may refuse (uncommitted changes would conflict) or carry
    them along messily
  → commit half-done work? No — it's not ready (pollutes history)
→ STASH saves your changes aside, giving you a clean working directory to switch.
```

## Using stash

```bash
git stash                      # save uncommitted changes; working dir becomes clean
git stash push -m "message"    # stash with a description
git stash list                 # list stashes (stash@{0}, stash@{1}, ...)

git stash pop                  # RESTORE the latest stash AND remove it from the list
git stash apply                # restore but KEEP it in the stash list
git stash apply stash@{1}      # apply a specific stash
git stash drop stash@{0}       # delete a stash
git stash clear                # remove all stashes
```

`git stash` saves changes and cleans the working directory; `git stash pop` restores them later (and removes the stash). `apply` restores without removing.

## Common scenario

```bash
# working on a feature, but an urgent bug needs fixing on main:
git stash                      # save the in-progress feature work
git switch main
# ... fix the urgent bug, commit, push ...
git switch feature
git stash pop                  # restore the feature work and continue
```

## Useful options

```text
git stash -u        → also stash UNTRACKED files (not just tracked changes)
git stash show -p   → see what's in a stash
→ Stash is for TEMPORARY storage — not a substitute for commits/branches long-term.
```

## Why it matters

Understanding `git stash` is valuable for **handling context switches cleanly**, a common real-world situation, so it's useful practical Git knowledge.

The problem it solves is frequent: you're in the middle of work with uncommitted changes when you need to **switch context urgently** (fix a production bug on another branch, review someone's code, pull updates) — but switching branches with uncommitted changes is problematic (Git may refuse or carry them messily), and committing half-done work pollutes history. **Stash** elegantly solves this by **saving your changes aside** and giving you a clean working directory to switch contexts, then **restoring them later** when you return — exactly fitting the common "I need to drop what I'm doing temporarily" scenario.

Understanding the core commands (`git stash` to save, `git stash pop` to restore-and-remove, `git stash apply` to restore-and-keep, `git stash list` to see stashes) and the typical workflow (stash in-progress work, switch and handle the urgent task, switch back and pop) is practical everyday knowledge for managing interruptions.

Knowing useful options (`-u` to include untracked files, viewing stash contents) and that stash is for **temporary** storage (not a long-term substitute for commits/branches) reflects proper usage.

Since context switches and interruptions are common in development (urgent bugs, reviews, needing a clean working directory), and since stash provides a clean, convenient way to temporarily set aside uncommitted work and restore it later, understanding `git stash` — what it solves, the commands, and the common context-switch workflow — is valuable, practically-relevant Git knowledge for handling the frequent real-world need to switch contexts without committing unfinished work, a handy tool that smooths the common interruptions of daily development.