Himanshu SharmaSoftware engineer
Let’s talk

Git and GitHub · Lesson 8 of 30

Fixing the last commit: amend and the three kinds of reset

Fix a typo or a forgotten file with git commit --amend, and understand what git reset --soft, --mixed and --hard do to the three areas of Git.

14 minUndoing things safelyUpdated 14 November 2026

Awaiting technical review. This lesson is readable but not yet listed in search engines.

By the end of this lessonAmend the latest commit, choose between soft, mixed and hard reset, and know which of them can destroy uncommitted work.

What you can do after this lesson

You will fix the most common small mistakes (a typo in a message, a forgotten file) and you will understand git reset, the command people fear most. The fear is reasonable but fixable: once you know what each mode touches, reset becomes predictable. Examples use a fictional shopping list with three commits. Hashes on your machine will differ.

Amending the last commit

git commit --amend replaces the latest commit rather than adding a new one. To fix a message:

bash
git commit --amend -m "Add salt to the shopping list"
git log --oneline
text
[main 0b9e972] Add salt to the shopping list
 Date: Tue Nov 10 10:00:00 2026 +0000
 1 file changed, 1 insertion(+)
0b9e972 Add salt to the shopping list
f2afcbf Add yeast
4c52fa5 Add shopping list

Compare this with the commit before the amend: the message is new, and the hash is also new. That is not a quirk. A commit's identity comes from its content, so changing anything creates a different commit, and the old one is simply abandoned.

To add a forgotten file, stage it and amend without changing the message:

bash
echo "sugar" > extra.txt
git add extra.txt
git commit --amend --no-edit
git show --stat --oneline
text
[main ffbb9f2] Add salt
 Date: Tue Nov 10 10:00:00 2026 +0000
 2 files changed, 2 insertions(+)
 create mode 100644 extra.txt
ffbb9f2 Add salt
 extra.txt | 1 +
 shopping.txt  | 1 +
 2 files changed, 2 insertions(+)

The commit now holds both files. Golden rule: amend only commits you have not shared. If someone already pulled the old commit, your new version conflicts with theirs. Shared mistakes are fixed with git revert, covered in the next lesson.

What git reset does

A branch is a label pointing at a commit. git reset <commit> moves the current branch label to another commit. What happens to your files depends on the mode:

Mode Branch moves Staging area Working tree
--soft yes unchanged unchanged
--mixed (default) yes reset to match unchanged
--hard yes reset to match reset to match

Think of it as how far the reset reaches through the three areas from lesson 3: soft touches only the repository, mixed also touches the staging area, hard reaches all the way into your files.

Let us reset from the same starting point three times. In each case the history was Add shopping list, Add yeast, Add salt.

Soft: undo the commit, keep everything staged

bash
git reset --soft HEAD~1
git log --oneline
git status -s
cat shopping.txt
text
f2afcbf Add yeast
4c52fa5 Add shopping list
M  shopping.txt
buy flour
buy yeast
buy salt

The Add salt commit is gone from the log, but its change is still staged and still in the file. This is ideal for squashing: reset soft over several commits and make a single new one from the combined changes.

Mixed: undo the commit, keep the edits unstaged

bash
git reset HEAD~1
git status -s
git diff
text
Unstaged changes after reset:
M	shopping.txt
 M shopping.txt
diff --git a/shopping.txt b/shopping.txt
index 21c118a..a286201 100644
--- a/shopping.txt
+++ b/shopping.txt
@@ -1,2 +1,3 @@
 buy flour
 buy yeast
+buy salt

Mixed is the default when you give no mode. The commit is undone and the change returned to your working tree, ready to be re-staged selectively and recommitted.

Hard: undo the commit and discard the changes

bash
echo "scribble" >> shopping.txt
git status -s
git reset --hard HEAD~1
git status -s
cat shopping.txt
text
 M shopping.txt
HEAD is now at f2afcbf Add yeast
buy flour
buy yeast

Both the commit and the uncommitted scribble vanished, and the status is clean. Of the three modes this is the only one that can lose work, and the unstaged scribble is lost for good. The committed Add salt change is not: Git still holds it, and the reflog finds it.

bash
git reflog
git reset --hard HEAD@{1}
cat shopping.txt
text
f2afcbf HEAD@{0}: reset: moving to HEAD~1
aa986bd HEAD@{1}: commit: Add salt
f2afcbf HEAD@{2}: commit: Add yeast
4c52fa5 HEAD@{3}: commit (initial): Add shopping list
HEAD is now at aa986bd Add salt
buy flour
buy yeast
buy salt

HEAD@{1} means "where HEAD was one move ago". The next lesson digs into reflog properly.

Resetting to other targets

You are not limited to HEAD~1. git reset --hard origin/main makes your branch match the remote's exactly, and git reset --soft <hash> rewinds to any commit by its hash. Resetting also accepts file paths (git reset shopping.txt), in which case it unstages that file, doing the same job as git restore --staged.

When rewriting is safe

Amend and reset rewrite your own branch. That is fine for local, unshared commits, and you will often do it to tidy up before sharing. Once other people have fetched the commits, rewriting forces them to repair their copies. For shared history, add a new commit that undoes the change instead.

Choosing between the tools

A quick rule of thumb: if the problem is in the last commit only, amend it. If the problem spans several recent commits that nobody else has, use a soft or mixed reset and recommit them in a better shape. If you want to throw away both commits and edits, use a hard reset, but only after git status shows nothing you care about. If anyone else might have the commits, stop and use revert instead. Pausing to classify the situation takes a moment and avoids most regrets.

Common mistakes

  • Using --hard with uncommitted work present. Run git status first, and stash or commit what you want to keep.
  • Amending a pushed commit. You will need a force push and your teammates will have to reconcile.
  • Forgetting the default is mixed. git reset HEAD~1 leaves your changes unstaged, so a following git commit finds nothing to commit.
  • Typing HEAD~ with the wrong number. Check git log --oneline first.
  • Panicking after a hard reset of committed work. Look at git reflog before anything else.

Exercise

  1. Make three commits in a scratch repository.
  2. Reword the last message with --amend.
  3. Use git reset --soft HEAD~2 and make one commit from the two undone ones.
  4. Make a deliberate mistake with git reset --hard HEAD~1 and recover with reflog.
Show one possible answer
bash
git commit --amend -m "Clearer message"
git reset --soft HEAD~2
git commit -m "Combine the last two changes"
git reset --hard HEAD~1
git reflog
git reset --hard HEAD@{1}

After the final command your branch is back where it was before the hard reset.

Next: Undoing shared history with revert, and finding lost work with reflog.

Key points

  • git commit --amend replaces the latest commit with a new one, so it changes the hash and should not be used on commits others already have.
  • git reset moves the current branch to another commit; the mode decides what happens to the staging area and working tree.
  • --soft keeps changes staged, --mixed (the default) keeps them unstaged, and --hard discards them.
  • Only --hard (and git clean) can lose uncommitted work; the commits themselves usually stay recoverable through reflog.
  • Rewriting history is safe for commits that exist only on your machine and risky for shared ones.

Check yourself

1. You committed and forgot to add one file. The commit has not been pushed. What fixes it with the least fuss?
2. What does git reset --soft HEAD~1 do?
3. Which reset mode can permanently lose uncommitted edits?
4. Why does git commit --amend change the commit's hash?