Git Reset

Change the last unpublished commit, restore files, and use mixed, soft, and hard reset only when you can name the risk.

Name the state before choosing the command

Ask three questions before correcting history

1. SCOPE
   Which state is wrong?

   The latest commit, the staged proposal, an unstaged file, or the current branch tip require different operations.

2. VALUE
   Which content must survive?

   Name the exact committed, staged, unstaged, and untracked work you intend to keep.

3. SHARING
   Has the commit been published?

   Rewriting a shared commit changes its ID and can break another person’s ancestry.

4. EVIDENCE
   Can you prove the current state?

   Capture status, relevant diffs, branch name, and commit IDs before changing pointers or files.

Amend the latest unpublished commit

git commit --amend does not edit a commit in place. It creates a new commit, normally with the same parent as HEAD, then moves the current branch to the replacement. The old and new commits have different object IDs even if only the message changes.

# Inspect before changing the latest commit
git status
git diff
git diff --cached
git show --stat HEAD

# Stage the intended correction, then replace HEAD
git add path/to/file
git commit --amend

# Keep the existing message when only the snapshot changes
git commit --amend --no-edit

Use restore for file-level state changes

git restore copies content from a source into one or more destinations. By default, the destination is the working tree and the source is the index. With --staged, the destination includes the index and the default source becomes HEAD.

# Discard unstaged changes in one tracked path:
git restore -- path/to/file

# Unstage a path while keeping its working copy:
git restore --staged -- path/to/file

# Restore a path from a named commit into the working tree:
git restore --source=HEAD~1 -- path/to/file

# Update both index and working tree from a named commit:
git restore --source=HEAD~1 --staged --worktree -- path/to/file

Choose restore by scenario

Reset moves the current branch

At commit level, git reset TARGET moves the current branch tip to TARGET. The mode controls whether Git also resets the index and tracked working-tree content. This changes which commits the branch reaches, so inspect the graph and copy the current tip ID first.

# Move the current branch; keep index and working tree unchanged
git reset --soft HEAD~1

# Move the current branch; reset index; keep working files
git reset --mixed HEAD~1

# Move the current branch; reset index and tracked working files
git reset --hard HEAD~1

Predict the result before reset

Build a recovery point first

git status --short
git diff
git diff --cached
git log --oneline --decorate -5
git rev-parse HEAD

# Give the current commit a temporary recovery name when appropriate:
git branch recovery/before-reset HEAD

# Verify the ref before changing the original branch:
git show --stat recovery/before-reset

A temporary branch protects committed history by keeping the old commit reachable. It does not preserve unstaged or untracked content. Save or commit valuable uncommitted work using an approved workflow before an operation that could overwrite it.

Recover a moved branch tip with reflog

The local reflog records recent updates to refs such as HEAD. If reset moved a branch away from a committed tip, inspect the reflog, identify the exact prior commit, and create a recovery branch before doing more work.

git reflog --date=iso
git show --stat HEAD@{1}

# After verifying the object:
git branch recovery/lost-tip HEAD@{1}
git log --oneline --decorate --graph --all

Reflog is local, temporary recovery metadata—not a substitute for a shared remote or a preservation plan. Entries expire, differ between clones, and cannot reconstruct arbitrary working-tree text that Git never stored.

Guided practice: correct without losing work

Create a disposable repository with a README and two source files. Make at least three small commits so every pointer movement is visible.

1. 01
   Amend locally

   Make a fourth commit with an incomplete README, stage the correction, amend with the same message, and prove the object ID changed.

2. 02
   Separate staged state

   Edit two files, stage both, then unstage one with restore while keeping both working copies.

3. 03
   Discard one known edit

   Inspect the unstaged patch for one disposable line and restore only that path.

4. 04
   Compare reset modes

   Create a recovery branch, then use soft and mixed reset in turn. Record branch, index, and working-tree results.

5. 05
   Recover the tip

   Locate the prior committed tip in reflog, create a recovery branch there, and draw the complete graph.

Independent lab: repair a mistaken local commit

In a disposable repository, create a clean three-commit history. Then create a fourth commit that combines one intended source edit, one unrelated documentation edit, and an inaccurate message. Without deleting any wanted content:

1. Record status, both diffs, the graph, and the original HEAD ID.
2. Create and verify a recovery branch at the original tip.
3. Use mixed reset to move the original branch back one commit while retaining working files.
4. Stage and commit the source change with an accurate message.
5. Stage and commit the documentation change separately.
6. Add an unstaged disposable edit, prove its exact patch, and restore only that path.
7. Use reflog and the recovery branch to explain where the original combined commit remains reachable.
8. Finish with clean status and a graph showing the repaired branch and recovery pointer.

Common correction mistakes

Lesson review

You can now correct unpublished history without treating Git’s recovery commands as interchangeable. You can replace the latest local commit, move file content between states, predict each reset mode, preserve a committed recovery point, and use reflog without overpromising what it stores.

• I know amend creates a replacement commit with a new object ID.
• I distinguish discarding an unstaged edit from unstaging content I want to keep.
• I can predict branch, index, and working-tree state after soft, mixed, and hard reset.
• I inspect and preserve valuable work before moving pointers or overwriting files.
• I reserve history rewriting for unpublished work or an explicitly coordinated workflow.