Git Discard Changes Explained (Undo, Remove, Reset All Changes with Examples)

Discarding changes in Git is a common task when you want to undo changes, remove local changes, or reset your repository to a clean state.

In Git, you can discard changes in multiple ways depending on where they exist — whether they are unstaged, staged, or already committed. Common commands used include git restore, git reset, git clean, and git stash.

In this guide, you will learn:

• How to discard changes in Git
• How to discard local changes safely
• How to remove all changes in Git
• How to undo changes using different Git commands

This tutorial covers real-world scenarios and best practices to help you safely discard changes without losing important work.

Git Discard Changes - Quick Cheat Sheet

What Does "Discard Changes" Mean in Git?

In Git, discarding changes means removing modifications that you no longer want to keep in your repository. These changes can exist in different stages such as the working directory (unstaged), staging area (staged), or even committed history.

Depending on where the changes exist, Git provides different commands like git restore, git reset, git clean, and git revert to safely or permanently discard them.

Discarding changes in Git means undoing modifications from working directory, staging area, or commit history using appropriate commands.

Working directory vs staging vs commits

To properly discard changes, you must understand Git’s three main states:

• Working Directory (Unstaged Changes)
  Files you modified but haven’t added using git add
  → Use: git restore

• Staging Area (Index / Staged Changes)
  Files added using git add but not committed using git commit
  → Use: git restore --staged or git reset

• Commit History (Committed Changes)
  Changes already saved in Git history using git commit
  → Use: git revert or git reset

When you should discard changes vs keep them

You should discard changes when:

• Changes are experimental or incorrect
• You want to revert to last working version
• You accidentally modified or staged files
• You want to clean your working directory

You should NOT discard changes when:

• Changes are important but incomplete → use git stash
• You are unsure → take backup or stash first
• Changes are already pushed → use git revert instead of reset

Git Discard vs Remove vs Undo Changes

In Git, different users use different terms for the same action:

• Discard changes in Git → Remove unwanted modifications
• Remove changes in Git → Delete local updates
• Undo changes in Git → Revert to previous state
• Delete changes in Git → Permanently remove modifications

All these actions can be performed using commands like

• git reset
• git clean
• git revert
• git restore

Understanding the Git Discard Workflow

The above workflow diagram simplifies how to decide which Git command to use when discarding changes:

1. Start with unwanted changes

   • Files you modified (after using git add or before committing with git commit) and now want to discard them

2. Check if changes are staged

   • If No (unstaged changes):

     • Use:
       • git restore . → discard all changes
       • git restore <file> → discard specific file
       • git clean -f → remove untracked files

   • If Yes (staged changes):

     • Use:
       • git restore --staged <file> → unstage changes
       • git reset --hard → discard everything (dangerous)

3. If changes are already committed

   • Use:
     • git revert <commit> → safe undo
     • git reset --hard → remove commits (use carefully)
     • git stash → temporarily save changes

Key Insight:
The correct command depends on where your changes exist (unstaged, staged, or committed). Using the wrong command can lead to permanent data loss, especially with git reset --hard.

How to Discard Unstaged Changes in Git

Unstaged changes are modifications in your working directory that have not been added using git add.

Discard changes in a specific file (git restore )

To discard changes in a single file:

git restore app.py

This will:

• Restore the file to its last committed state
• Remove all local modifications

Quick Tip:
Use this when you made unwanted edits to a file and want to revert it.

Discard all local changes (git restore .)

To discard all unstaged changes in the repository:

git restore .

This will:

• Reset all modified files
• Keep staged and committed changes untouched

Discard Staged Changes (Unstage Changes)

Staged changes are files added using git add and ready to be committed.

Remove file from staging area (git restore --staged)

To unstage a specific file:

git restore --staged app.py

This will:

• Move the file from staging area → working directory
• Keep your changes intact

Unstage all changes safely

To unstage all files:

git restore --staged .

Alternative (older command):

git reset

How to Discard All Local Changes in Git (Reset Everything)

This is used when you want to completely clean your working directory.

Use git reset --hard HEAD

git reset --hard HEAD

This will:

• Remove all staged and unstaged changes
• Reset repository to last commit

Difference between reset --soft, --mixed, --hard

Quick Insight:

• Use --soft → undo commit only
• Use --mixed → unstage changes
• Use --hard → delete everything

How to Remove Untracked Files in Git (git clean)

Untracked files are files not added to Git (not part of repo).

Use git clean -f and -fd

Remove untracked files using git clean

git clean -f

Remove untracked files and directories:

git clean -fd

Safe dry run using git clean -n

Before deleting files, always preview:

git clean -n

This shows:

• Which files will be removed
• Helps avoid accidental deletion

Best Practice:
Always run git clean -n before git clean -f

Temporarily Discard Changes (Safe Method)

Sometimes you don’t want to permanently delete changes — instead, save them temporarily using git stash—you just want to set them aside temporarily.

Use git stash to save changes

You can use git stash:

git stash

This will:

• Save both staged and unstaged changes
• Clean your working directory

Add a message:

git stash save "WIP changes"

Restore stashed changes later

View stashes:

git stash list

Apply stash:

git stash apply

Apply and remove stash:

git stash pop

Delete stash:

git stash drop

Best Use Case:
When switching branches or testing something without losing work.

Undo Already Committed Changes

When changes are already committed, you must use different approaches.

Use git revert (safe for shared repos)

git revert <commit>

This will:

• Create a new commit that undoes previous changes
• Preserve Git history (safe for teams)

Recommended for:
Shared repositories and pushed commits

Use git reset (dangerous but powerful)

git reset --hard HEAD~1

This will:

• Remove the last commit completely
• Delete associated changes

Discard Changes for a Single File Only

Useful when you want to discard changes in just one file instead of the entire repo.

Restore file to last commit

git restore app.py

This will:

• Discard all changes in the file
• Restore from last commit (HEAD)

Restore file from specific commit

git restore --source=<commit> app.py

Example:

git restore --source=HEAD~1 app.py

This helps:

• Recover older file versions
• Compare and selectively restore

Common Mistakes While Discarding Changes (High Ranking Section)

Difference between restore, reset, checkout confusion

Key Tip:
Use git restore for discarding changes instead of checkout.

Why changes are not getting discarded

Common reasons:

• Changes are already staged → use --staged
• Changes are committed → use reset or revert
• File is untracked → use git clean
• Wrong command used for the state

Check current state using git status:

git status

Risk of git reset --hard (data loss)

git reset --hard

Safer alternative:

git stash

Golden Rule:
If unsure → stash first, then proceed

Summary

Discarding changes in Git depends on where your changes exist in the workflow involving git add, git commit, and cleanup commands like git clean

• Unstaged changes → git restore
• Staged changes → git restore --staged or git reset
• Untracked files → git clean
• Committed changes → git revert or git reset
• Temporary discard → git stash

Understanding these scenarios helps you choose the right command and avoid data loss.

Official Documentation

• Git Restore Documentation
• Git Reset Documentation
• Git Clean Documentation
• Git Stash Documentation
• Git Revert Documentation