How to Undo git add - Removing Added Files in Git

Three distinct methods to undo a git add and restore harmony to your Git workflow.

Have you ever accidentally added files to your Git staging area that you didn't intend to commit? Or perhaps you realized you need to unstage specific changes before creating a commit? 

In this guide, we'll walk you through the process of undoing git add, ensuring you have the skills to manage your Git repository effectively. 

Key Takeaways 

  • You can use the git status command to identify files you currently have staged for commit.
  • Undoing git add is useful in scenarios such as unintentional file staging, excluding specific changes, and reorganizing commits.
  • git reset options offer flexible levels of reset, allowing you to effectively manage changes in the working directory.

Understanding Staging in Git

Before diving into the solutions, let's refresh our understanding of the Git staging area. The staging area, or index, acts as a middle ground between your working directory and the repository. It allows you to selectively choose which changes to include in the next commit and which files to leave out. This helps keep the repository organized and ensures that the changes you wish to commit are properly reviewed and tested before becoming a part of the main codebase.

Identifying the Files to Undo

To start the process of undoing a git add, we first need to identify which files are currently staged. The git status command is your ally here. Running this command provides a snapshot of the working directory, indicating the files that have been modified, staged, or remain untracked.

How to Undo a git add 

Let’s now look at three methods of undoing git add. Keep in mind that the appropriate method depends on your preference. 

Method 1: Using git reset

The git reset command is a powerful tool that offers flexibility in undoing git add. Let's explore the various ways it can be leveraged:

  1. Undo the Last git add and Keep Changes in the Working Directory:

To undo the last git add while retaining changes in your working directory, use this command:

git reset --soft HEAD

Note: This command resets the staging area to the latest commit (HEAD) while keeping the changes in your working directory.

  1. Unstage Specific Files:

To unstage specific files, you can run the following command:

git reset <file>

Note: Replace <file> with the actual file name. This command unstages changes for the specified file.

  1. Unstage All Changes:

When you need to unstage all changes, simply run this command:

git reset

Note: This command unstages all changes in the staging area, leaving your working directory untouched.

  1. Discard Changes Entirely:

To completely discard all changes, including modifications in your working directory, you can use the following command:

git reset --hard HEAD

Note: Exercise caution, as this command discards all changes, reverting both the staging area and the working directory to the state of the previous commit.

Method 2: Using git restore

If you're working with Git version 2.23 or newer, the git restore command provides a more streamlined approach to undoing git add. Here are two scenarios:

  1. Unstage Specific Files:

To unstage specific files, use this command:

git restore --staged <file>

Note: This command unstages changes for the specified file, similar to git reset <file>.

  1. Unstage All Changes:

When a broader reset is in order, unstage all changes using this command:

git restore --staged .

Note: This command unstages all changes in the staging area, similar to git reset.

Method 3: Using git rm --cached (for Untracked Files)

For scenarios involving untracked files mistakenly added to the staging area, git rm --cached comes to the rescue:

  1. Unstage Untracked Files:

To unstage untracked files, execute:

git rm --cached <file>

Note: This command removes the file from the staging area while keeping it in your working directory.

To learn more about git reset, check out our blog post: How to Uncommit Last commit in Git (5 Scenarios)

Tips and Best Practices

Keep these tips and best practices in mind when undoing git add:

  • Double-check changes before committing: Review changes before adding them to the staging area to avoid accidental additions.
  • Use .gitignore: Employ a .gitignore file to prevent unwanted files from being staged initially.
  • Exercise caution when running `git reset --hard HEAD`: Be careful when using this command as it discards all changes, reverting both the staging area and the working directory to the state of the previous commit. Use it judiciously to avoid unintended data loss.


Q1. Can I undo the last `git restore` command?

No, the git restore command is not directly reversible. It's crucial to double-check the files and options before running it.

Q2. What happens if I undo a `git add`, and then make additional changes?

If you undo a Git add using git reset or git restore and then make additional changes, the new changes won't be affected. The undo operation only applies to the state at the time of the undo command.

Q3. Is `git reset` safe to use in a collaborative environment?

It depends on the situation. While git reset is a powerful tool, using it to rewrite history can cause issues in a collaborative environment. Communicate with your team before using reset commands that alter shared history.

Q4. Can I undo staging for specific lines of code within a file?

Git operates on a file level, so you can't directly unstage specific lines. 

Q5. What should I do if `git reset --hard HEAD` deleted uncommitted changes?

If you've lost uncommitted changes due to a hard reset, recovery is challenging. Regularly commit or stash changes before using a hard reset to prevent accidental data loss. In extreme cases, file recovery tools may be needed.


There you have it – three distinct methods to gracefully undo a git add and restore harmony to your Git workflow. Whether you prefer the nuanced control of git reset, the streamlined approach of git restore, or need to address untracked files with git rm --cached, you are now equipped to navigate the intricacies of staging in Git with confidence. 

To learn more, consider our Git Courses

GitHub Actions | KodeKloud
GitOps with FluxCD | KodeKloud
Automate your application deployments seamlessly by mastering GitOps with Flux using animated slides, practical demos, and interactive labs in this hands-on course for developers, DevOps engineers, cluster operators, and anyone who wants to automate application deployment
GitOps with ArgoCD | KodeKloud