Git Stash List: 10 Reliable Steps to Naming, Searching, and Applying Stashes

Ever paused mid-feature because a bug needed hot-fixing on another branch? That’s the perfect moment for the stash list to shine. Stashing lets you snapshot work-in-progress without committing, switch context safely, and come back with zero drama. In this guide, we turn the Git Stash List from a plain stack of “WIP” entries into a tidy, searchable system you can actually trust.

You’ll learn how to create named stashes, filter the list by time or message, preview diffs, and apply or pop changes—plus a handful of best practices that keep your workflow smooth when context switches pop up out of nowhere.

If you bounce between branches for bug fixes and feature work, the command that keeps your momentum is the stash list. It’s the index of everything you’ve shelved: quick experiments, half-finished refactors, and emergency fixes you had to postpone

In this deep dive, we’ll turn the Stash List overview from a simple dump of entries into a searchable, named, and reliable inbox for your work-in-progress.

A 60-second refresher (so the Git saved Stash List makes sense)

When you run git stash (or the explicit git stash push), Git captures your working tree and index into a special commit and rolls your workspace back to HEAD. Your stash overview shows those temporary snapshots in a stack: the newest at stash@{0}, then stash@{1}, and so on.

For an overview of stash basics, Atlassian’s primer on stashing is solid reading (tutorial).

Quick start:

# Save changes with a clear message and keep staged items staged
git stash push -m "feat: profile page layout WIP" --keep-index

# See everything in your saved Stash List
git stash list

# Re-apply the most recent stash without removing it
git stash apply

# Or apply and drop it in one go
git stash pop

# Show what a particular stash contains (summary or patch)
git stash show stash@{2}
git stash show -p stash@{2}

Note: git stash and git stash push They are equivalent for quick snapshots. Use push When you need options like -m/--message, --patch, --include-untracked, or pathspecs.

Why naming matters (and how it upgrades your Stash List)

A bare Git Stash List full of “WIP on main” isn’t helpful. Add messages so future-you can recognize entries instantly:

git stash push -m "fix: debounce search input"
git stash push -m "chore: bump axios + update types"
git stash push -m "spike: CSS container queries"

These messages appear directly within your stash entries, making it easy to locate the correct stash on a busy day.

If you previously used git stash save "message", that still works, but it is deprecated in favor of git stash push -m "message". Prefer push -m going forward — see the official docs for options like --patch, --include-untracked, and more.

Reading the Git Stash List like a pro

The list supports all the usual git log filters. That means you can search, sort, and slice your stashes instead of scrolling forever.

# Filter by message text
git stash list --grep "debounce"

# Limit by time ranges (recent week)
git stash list --since="1 week ago"

# Combine: messages mentioning 'login' created before June
git stash list --grep "login" --before="2025-06-01"

# Show stats or full patches right from the list
git stash list --stat
git stash list -p

Need to inspect the exact diff for a single entry? Pair git stash show with -p:

git stash show -p stash@{1}

This makes the Stash List not just an index but a navigable changelog of your WIP.

Retrieving by index vs. retrieving by name

You can always grab entries by index:

git stash apply stash@{3}   # leaves it in the saved stashe list
git stash pop   stash@{3}   # applies then removes

But when messages are descriptive, “retrieving by name” becomes natural:

# Find the stash whose message includes 'container queries'
git stash list --grep "container queries"

# Then apply the one you want
git stash apply stash@{1}

For scripted workflows, resolve a stash commit ID and work with it directly:

# Resolve the commit-ish for the nth stash
git rev-parse stash@{2}

# Show the message and patch using standard tools
git show --name-status stash@{2}

Untracked and ignored files in your Git Stash List

By default, git stash only saves tracked modifications. If you’re prototyping new files, add them too:

# Include untracked files
git stash push -u -m "feat: add ProfileCard component (skeleton)"

# Include untracked + ignored files (rare; use sparingly)
git stash push -a -m "test: snapshot output including .env mocks"

Those entries will appear in your saved stashes alongside regular stashes, properly labeled by your message.

Partial stashes: capture only the pieces you need

Sometimes you want to park only part of your changes—say, the CSS tweaks, but not the API work. Use patches, pathspecs, or staged-only flags:

# Interactively choose hunks to stash
git stash push -p -m "style: header alignment tweaks"

# Stash only what is currently staged (great for isolating an unrelated fix)
git add src/utils/date.ts
git stash push --staged -m "fix: correct UTC offset handling"

# Stash only specific paths
git stash push -m "wip: home page layout only" -- src/pages/index.tsx src/styles/home.css

Organizing partial work this way keeps the Stash List clean and purposeful.

Safer applies, fewer conflicts

When reapplying, two flags matter:

# Try to restore both working tree and index as they were
git stash apply --index stash@{0}

# If you expect conflicts, create a branch from the stash baseline
git stash branch fix/login-modal stash@{0}

Creating a branch from a stash can be the difference between a smooth reapply and a tangled conflict—especially if the base branch has moved. Once you’re done and verified, you can drop the entry:

git stash drop stash@{0}   # remove one
git stash clear            # remove all (dangerous; not easily reversible)

Make the saved stashes searchable with naming conventions

Treat your stash messages like commit messages:

• type: feat, fix, docs, style, refactor, test, chore, spike
• scope: component, module, or area (e.g., auth, checkout, profiles)
• brief reason: 4–8 words describing intent

Examples:

fix(auth): debounce login form submit
feat(profile): add avatar cropping flow (WIP)
refactor(ui): replace grid with CSS container queries

Now git stash list --grep "feat(profile)" or --grep "auth" is laser-precise. Your Stash List becomes self-documenting.

Practical scenario walk-through

Imagine you’re midway through a new ProfileCard component:

# You created new files and tweaked existing ones
git status
# ... shows modified tracked files + new files

# Stage the CSS you’re confident about; stash the rest
git add src/components/ProfileCard.css
git stash push --staged -m "style(profile): finalize card spacing"

# Keep exploring JS changes; later you need to switch branches fast
git stash push -u -m "feat(profile): build card skeleton"

# Jump away and fix a hot bug on main...
# ...later, come back and list what’s waiting
git stash list --since="2 days ago" --grep "profile"
git stash show -p stash@{0}

# Re-apply the safe CSS first, then the feature skeleton
git stash apply stash@{1}
git stash pop   stash@{0}

You switched contexts twice without losing work, and your list of stashes told the story at a glance.

Integrate the Stash List into your daily routine

• Use -m on every stash. Empty messages are invisible in the Stash List.
• Keep entries short-lived; drop what you’ve merged to prevent list bloat.
• Grep and time-filter your stash entries weekly to clean up leftovers.
• Reach for git stash branch when pop/apply looks risky.
• Prefer partial stashes (-p, --staged, pathspec) to avoid giant, messy entries.

Related Git skills that pair well

If you’re moving work across branches, you’ll often hop to topics like unstaging files, user configuration, and moving commits. For step-by-step guides, see:

• Move a commit to another branch
• Unstage files in Git
• Git User Configuration
• Git Submodule Update basics

These skills complement a tidy stash overview, especially when you’re tidying up a feature branch before a PR.

Under the hood: what a stash actually is

Each stash entry is a regular Git commit object—actually, a mini merge commit with two parents. One parent points to the tree of your index at the time of stashing; the other captures the working tree. That’s why you can inspect a stash with regular tooling:

git show --name-status stash@{0}
git diff stash@{0}^!           # diff the stash itself

Because a stash is just commits, powerful tricks become possible: you can cherry-pick from a stash commit, create a new branch at the stash’s base with git stash branch, or even export/import stashes for hand-off. Knowing this makes the list feel less magical and more predictable—when something goes wrong, you can fall back to standard Git plumbing.

Common mistakes and quick fixes

• Forgetting untracked files. Add -u when you prototype new files so they’re included.
• Conflicts on apply. Prefer git stash branch to re-apply on the original base; resolve there, then merge forward.
• Letting the list grow forever. Calendar a five-minute cleanup: git stash list --since="3 months ago" to see what’s stale, then drop.
• Opaque messages. Adopt a message convention; future-you will thank present-you.

Team norms that help

If multiple devs use the same machine or shared remote stashes, align on message prefixes like spike:, hotfix:, and scopes like (auth) or (payments). This way, a teammate scrolling the stash list gets immediate context without opening patches.

One more power move: export and import stashes

Need to transfer stashes between clones or teammates? Newer Git versions include experimental export/import support:

# Export one or more stashes
git stash export --to-ref refs/transfer/stashes stash@{0} stash@{3}

# On another clone, import them
git fetch origin refs/transfer/stashes:refs/transfer/stashes
git stash import refs/transfer/stashes

This is niche, but can be a lifesaver for complex hotfixes. Your Stash List will show the imported entries just like local ones.

Cheatsheet: muscle-memory commands

# Save with message (tracked only)
git stash push -m "fix: calc rounding issue"

# Include untracked files
git stash push -u -m "wip: add hooks scaffolding"

# List, search, and inspect
git stash list
git stash list --grep "hooks" --since="1 week ago"
git stash show -p stash@{1}

# Retrieve
git stash apply stash@{1}   # keep in list
git stash pop stash@{1}     # remove from list

# Safer path
git stash branch rescue/feature stash@{1}

# Clean up
git stash drop stash@{1}
git stash clear

Once these are muscle memory, the stash entries become your second brain—not a junk drawer.

Here are a few small helpers I keep around to make the Git saved Stash List quicker to scan and act on.

Pretty stash list (short, colorized, relative dates)

# Add to your ~/.bashrc or ~/.zshrc
gstl() {
  git stash list --date=relative --pretty="%C(yellow)%gd%C(reset) %C(blue)%cr%C(reset) %s"
}
# usage: gstl

Apply a stash by fuzzy message match (first hit)

gsta() {
  if [ -z "$1" ]; then
    echo "usage: gsta <search-term>" >&2
    return 2
  fi
  local ref
  ref="$(git stash list --grep "$1" --format="%gd" | head -n1)"
  if [ -z "$ref" ]; then
    echo "No stash message matching: $1" >&2
    return 1
  fi
  echo "Applying $ref ..."
  git stash apply "$ref"
}
# usage: gsta "container queries"

Create a branch from the second-most recent stash

gsb2() {
  local ref="stash@{1}"
  echo "Creating branch from $ref ..."
  git stash branch "rescue/$(date +%Y%m%d-%H%M%S)" "$ref"
}
# usage: gsb2

I used to treat stashes as a junk drawer. Weeks later, I’d stare at a mile-long list, shrug, and nuke it. The turning point was naming every stash and cleaning the list on Fridays. Now my Git Stash List reads like a to-do queue: fix here, spike there, refactor later. The five minutes I spend writing messages and running gstl have paid for themselves a hundred times.

A clean stash list is more than a safety net—it’s a workflow accelerator. Name every stash, use filters to find what you need, preview before applying, and prefer git stash branch when the base has moved. Keep the list lean by dropping what’s done, and you’ll never fear context switches again. If this clicked, take ten minutes to wire up the helper aliases above and prune your list today.

FAQ