Undoing Changes — Reset, Revert, and Stash¶

Overview¶

Mistakes happen — wrong commit on main, accidental git add of secrets, need to context-switch mid-feature. Git provides reset, revert, restore, and stash to undo work at different levels. Choosing the wrong tool on shared branches causes outages; choosing the right one saves production.

This is Tutorial 13 in Module 5: Recovery & Debugging of the REBASH Academy Git series.

Prerequisites¶

• gitignore and gitattributes
• Basic Git Workflow — Add, Commit, Push

Learning Objectives¶

By the end of this tutorial, you will be able to:

• Distinguish reset, revert, restore, and stash
• Apply soft, mixed, and hard reset appropriately
• Revert commits on shared branches safely
• Stash and restore work-in-progress changes
• Unstage and discard working directory changes
• Know when NOT to reset shared history
• Recover from accidental hard reset using reflog

Undo Operations Diagram¶

flowchart TB
    WT[Working Tree]
    SA[Staging Area]
    REPO["Repository / Commits"]

    RESTORE1[git restore file] --> WT
    RESTORE2[git restore --staged] --> SA
    RESET["git reset --soft/mixed/hard"] --> SA
    RESET --> REPO
    REVERT[git revert] --> REPO
    STASH[git stash] --> WT
    STASH --> SA```

## Theory

### Levels of Undo

| Scope | Undo tool |
|-------|-----------|
| Uncommitted file edits | `git restore file` |
| Staged but uncommitted | `git restore --staged file` |
| Last commit (local, unpushed) | `git reset --soft HEAD~1` |
| Published commit on shared branch | `git revert` |
| Temporary context switch | `git stash` |

### git restore (Git 2.23+)

```bash
git restore app.yaml              # discard working changes
git restore --staged app.yaml     # unstage
git restore --source=HEAD~1 file  # restore file from old commit

Replaces older git checkout -- file pattern.

git reset — Three Modes¶

Moves branch pointer; optionally affects staging and working tree:

git reset --soft HEAD~1    # undo commit, keep changes staged
git reset HEAD~1           # undo commit, keep changes unstaged
git reset --hard HEAD~1    # destroy commit AND changes — dangerous

Hard reset on shared branches is catastrophic — use revert instead.

git revert¶

Creates a new commit that inverse-applies a previous commit:

git revert abc1234
git revert HEAD
git revert -m 1 MERGE_COMMIT   # revert merge (mainline parent 1)

Safe for production — history preserved; audit trail shows explicit undo.

git stash¶

Temporarily shelves uncommitted changes:

git stash push -m "wip: healthcheck"
git stash list
git stash pop                  # apply and remove
git stash apply stash@{0}      # apply keep stash
git stash drop stash@{0}

Stash including untracked:

git stash push -u -m "including new files"

Stash vs Commit¶

Stash for dirty tree when switching branches; commit for work worth preserving in history.

Reset vs Revert Decision Tree¶

• Unpushed local commits? → reset OK
• Already pushed to shared branch? → revert
• Need to remove secret from history? → filter-repo + force push (emergency, coordinated)

ORIG_HEAD and Reflog¶

Git saves previous HEAD in ORIG_HEAD after destructive operations. Reflog records all HEAD movements — recovery safety net (next tutorials expand).

Production Rollback Scenarios¶

In regulated environments, revert is preferred because compliance auditors see an explicit undo commit linked to the incident ticket. Reset on shared branches requires force push — almost never approved for main or production branches.

Stash Stack Management¶

Multiple stashes form a stack — newest first in git stash list:

git stash list
git stash apply stash@{2}    # apply older stash without removing
git stash drop stash@{0}     # remove top stash after manual merge
git stash clear              # delete all stashes — use carefully

Name stashes descriptively in team environments so stash@{0} is identifiable during incident handoffs.

Hands-on Lab¶

Step 1 – Setup with commits¶

Command:

mkdir -p /tmp/git-undo-lab && cd /tmp/git-undo-lab
git init -b main
echo "v1" > app.txt && git add . && git commit -m "feat: v1"
echo "v2" >> app.txt && git add . && git commit -m "feat: v2"
echo "v3" >> app.txt && git add . && git commit -m "feat: v3"
git log --oneline

Step 2 – Soft reset¶

Command:

git reset --soft HEAD~1
git status
git log --oneline -2
git commit -m "feat: v3 improved message"

Step 3 – Mixed reset and restore¶

Command:

echo "mistake" >> app.txt
git add app.txt
git reset HEAD app.txt
git status
git restore app.txt
cat app.txt

Step 4 – Stash workflow¶

Command:

echo "wip feature" >> feature.txt
git stash push -u -m "wip feature file"
git status
git stash list
git stash pop
git status

Step 5 – Revert (simulating shared branch)¶

Command:

BAD=$(git rev-parse HEAD~1)
git revert --no-edit "$BAD"
git log --oneline -5
cat app.txt

Step 6 – Hard reset and reflog recovery¶

Command:

BEFORE=$(git rev-parse HEAD)
git reset --hard HEAD~2
git log --oneline -3
git reset --hard "$BEFORE"
git log --oneline -3

Step 7 – Clean up¶

Command:

cd /tmp && rm -rf git-undo-lab

Commands & Code¶

Emergency revert script¶

#!/usr/bin/env bash
# revert-last-main.sh — safely revert latest commit on main
set -euo pipefail
git switch main
git pull --ff-only origin main
git revert --no-edit HEAD
git push origin main
echo "Reverted $(git rev-parse HEAD~1) on main."

Common Mistakes¶

Best Practices¶

Troubleshooting¶

Summary¶

• restore discards unstaged changes; restore --staged unstages
• reset --soft/mixed/hard moves branch pointer; hard destroys uncommitted work
• revert adds inverse commit — safe for shared/production branches
• stash temporarily shelves WIP for branch switches
• Unpushed history: reset OK; published history: revert; recovery: reflog

Interview Questions¶

1. What is the difference between reset and revert?
2. Explain soft, mixed, and hard reset.
3. When is hard reset appropriate?
4. How does git stash work?
5. How do you unstage a file without losing edits?
6. How do you revert a merge commit?
7. Why should you avoid reset on shared branches?
8. What is ORIG_HEAD?
9. How do you recover after accidental git reset --hard?
10. When use stash vs temporary commit?

Related Tutorials¶

• gitignore and gitattributes (previous — Module 4)
• Cherry-pick and Reflog (next)
• Rebasing and Interactive Rebase
• Git Bisect and Debugging History
• Git – Category Overview

References¶

• Pro Git Book – Undoing Things
• git reset documentation
• git revert documentation
• git stash documentation
• REBASH Academy – Git Overview