Recovering from Mistakes

Follow Us

Our Communities

Module 10 – Recovering from Mistakes

Welcome to Module 10, the final stage of our journey into the world of Git. Up to this point, we’ve learned how to set up repositories, manage files, and navigate the project history. But what happens when things go wrong? Fear not, Git is well-equipped with tools to help you recover from most mistakes.

In this module, we will explore Git’s powerful features for undoing changes and retrieving lost data. We will begin by discussing how to undo local changes and continue onto amending commits. Then, we’ll delve into more complex scenarios, such as undoing committed changes and recovering lost commits.

By the end of this module, you will have a thorough understanding of Git’s robust safety features. You’ll learn how to navigate around common missteps, and recover your work quickly and easily when things don’t go as planned. Remember, Git is designed with safeguards to prevent data loss, giving you the freedom to experiment and learn without fear of irreparable errors. So let’s get started!

Undoing Local Changes

Before changes are committed to the repository, they exist either in your working directory or the staging area.

  • Unstaging Files with git reset: If you’ve staged changes that you don’t want to commit, the git reset command is your friend. The command git reset HEAD <file> unstages changes made to a specific file, essentially moving the changes from the staging area back to the working directory. Using git reset without specifying a file unstages all changes.

  • Discarding Local Changes with git checkout and git restore: When you want to discard all local changes to a file, you can use git checkout -- <file>. This command will revert the file back to the state of the last commit. Similarly, the git restore <file> command will discard local changes and restore the file to the state of the last commit.

Amending Commits

Sometimes, a commit might not be quite right. Perhaps the commit message was misspelled, or an important file was accidentally left out. Git provides a mechanism for modifying the most recent commit.

  • Changing the Commit Message: To change the commit message of the most recent commit, you can use the command git commit --amend. This will open your text editor, allowing you to modify the commit message.

  • Adding, Changing, or Removing Files: If you need to add, modify, or remove files in the most recent commit, you can stage or unstage the changes as needed, then use git commit --amend to include these changes in the most recent commit.

Undoing Committed Changes

Once changes are committed, undoing them requires a bit more care. However, Git provides a couple of powerful tools for this task.

  • Reverting Commits with git revert: If you need to undo the changes made in a specific commit, you can use git revert <commit>. This command creates a new commit that undoes the changes made in the specified commit.

  • Resetting to a Previous Commit with git reset: The git reset command can also be used to “move” your current HEAD to a previous commit. There are three options to do this: git reset --soft <commit>, git reset --mixed <commit>, and git reset --hard <commit>, each having a different level of “reset strength”.

Recovering Lost Commits

In some situations, commits may seem to be lost or inaccessible. Thankfully, Git keeps a detailed log of where your HEAD and branch references have pointed in the past, making recovery possible.

  • Understanding the Reflog: The reflog is a mechanism that records when the tip of branches and other references were updated in the local repository. Using git reflog, you can see a list of your past actions. Each action is associated with a HEAD@{n} reference, which you can use to reference a previous state of your project.

  • Recovering Lost Commits: If you’ve “lost” a commit (for example, by using git reset --hard), you can find the commit reference in the reflog. Then, you can use commands like git cherry-pick <commit> or git merge <commit> to recover the commit.

By the end of this module, you should feel equipped to navigate common missteps and recover from errors with grace. Remember, Git is designed to prevent data loss. If you’re unsure about an operation, there’s likely a safe way to test it out or undo it.

Exercises and Practice

Exercise 1: Unstaging Files: Start by making changes to multiple files in a test repository and add them to the staging area using git add. Practice using git reset HEAD <file> to unstage specific files, and git reset to unstage all files.

Exercise 2: Discarding Local Changes: In your test repository, modify several files. Use git checkout -- <file> and git restore <file> to discard the changes in specific files. Observe how the changes are discarded and the files return to their state from the last commit.

Exercise 3: Amending Commits: Commit a change with a misspelled commit message. Use git commit --amend to correct the commit message. Then, make some changes to the files, add them to the staging area, and use git commit --amend to include them in the last commit.

Exercise 4: Reverting and Resetting Commits: Make and commit several changes in your repository. Use git revert <commit> to undo specific commits, creating a new commit that undoes the changes. Also, practice using git reset --soft <commit>, git reset --mixed <commit>, and git reset --hard <commit> to move HEAD to a specific commit.

Exercise 5: Recovering Lost Commits: Deliberately “lose” a commit using git reset --hard. Use git reflog to find the commit reference in the reflog. Then, recover the commit using git cherry-pick <commit> or git merge <commit>.


Remember, Git is very forgiving and most mistakes are recoverable. The key to mastering Git is to understand the underlying concepts and practice using the commands until they become second nature. Good luck!

Git Plumbing and Attributes


Git Tutorial