git reset soft vs mixed vs hard - Visual Side-by-Side Comparison

Process Flow - git reset soft vs mixed vs hard

Start: Commit History

↓

Choose Reset Type

↓

soft

↓

Move HEAD

↓

Changes staged

This flow shows how git reset moves HEAD and affects the staging area and working directory differently depending on soft, mixed, or hard options.

Execution Sample

Git

git reset --soft HEAD~1
# Moves HEAD back by one commit, keeps index and working directory

git reset --mixed HEAD~1
# Moves HEAD back by one commit, resets index, keeps working directory

git reset --hard HEAD~1
# Moves HEAD back by one commit, resets index and working directory

These commands move the current branch HEAD back by one commit with different effects on staged and unstaged changes.

Process Table

Step	Command	HEAD Position	Index (Staging Area)	Working Directory	Effect
1	Initial state	Commit C3 (latest)	Matches C3	Matches C3	All commits, index, and working directory in sync
2	git reset --soft HEAD~1	Commit C2	Matches C3	Matches C3	HEAD moved back, index and working directory unchanged, changes staged
3	git reset --mixed HEAD~1	Commit C2	Matches C2	Matches C3	HEAD and index moved back, working directory unchanged, changes unstaged
4	git reset --hard HEAD~1	Commit C2	Matches C2	Matches C2	HEAD, index, and working directory all reset to commit C2, changes discarded
5	End	At chosen commit	Index and working directory state depend on reset type	Working directory state depends on reset type	Reset complete

💡 Reset commands complete after moving HEAD and adjusting index and working directory according to reset type

Status Tracker

Variable	Start	After soft reset	After mixed reset	After hard reset
HEAD	C3	C2	C2	C2
Index	Matches C3	Matches C3	Matches C2	Matches C2
Working Directory	Matches C3	Matches C3	Matches C3	Matches C2

Key Moments - 3 Insights

Why does 'git reset --soft' keep changes staged even though HEAD moves back?

Because soft reset only moves HEAD pointer back but does not change the index or working directory, so staged changes remain as they were (see execution_table row 2).

What happens to unstaged changes after 'git reset --mixed'?

Unstaged changes remain in the working directory because mixed reset resets the index to the commit but leaves the working directory untouched (see execution_table row 3).

Why does 'git reset --hard' discard changes in the working directory?

Hard reset resets HEAD, index, and working directory to the specified commit, so any changes not committed are lost (see execution_table row 4).

Visual Quiz - 3 Questions

Look at the execution table. After 'git reset --soft HEAD~1', what does the index contain?

A Is empty

B Matches the commit HEAD points to (C2)

C Matches the latest commit C3

D Matches the working directory

💡 Hint

Check execution_table row 2 under 'Index (Staging Area)'

At which step does the working directory get reset to match the commit?

A After soft reset

B After hard reset

C After mixed reset

D Never

💡 Hint

See execution_table row 4 under 'Working Directory'

If you want to keep your working directory changes but unstage them, which reset should you use?

A git reset --mixed

B git reset --hard

C git reset --soft

D git reset --merge

💡 Hint

Look at how index and working directory change in execution_table rows 2 and 3

Concept Snapshot

git reset moves HEAD pointer and optionally resets index and working directory.
--soft: moves HEAD only, keeps index and working directory (changes staged).
--mixed (default): moves HEAD and resets index, keeps working directory (changes unstaged).
--hard: moves HEAD, resets index and working directory (changes lost).
Use carefully to manage commit history and staged changes.

Full Transcript

This visual execution shows how git reset commands affect the commit pointer (HEAD), the staging area (index), and the working directory. Starting from a state with three commits, we move HEAD back one commit with three reset types. Soft reset moves HEAD but leaves index and working directory unchanged, so changes remain staged. Mixed reset moves HEAD and resets the index to match the commit, but leaves working directory changes unstaged. Hard reset moves HEAD and resets both index and working directory to the commit, discarding any changes. The tables track these states step-by-step, helping beginners see exactly what changes and when. Key moments clarify common confusions about staging and discarding changes. Quizzes test understanding of index and working directory states after each reset type.

Practice

1. What does git reset --soft do to your changes after undoing a commit?

easy

A. It unstages the changes but keeps them in the folder.

B. It removes the changes from both staging and folder.

C. It keeps the changes staged and ready to commit again.

D. It deletes the commit and all changes permanently.

Solution

1. Step 1: Understand git reset --soft effect

   This option moves the HEAD pointer back but keeps all changes staged.

2. Step 2: Compare with other reset types

   Unlike mixed or hard, soft reset does not unstage or delete changes.

3. Final Answer:

   It keeps the changes staged and ready to commit again. -> Option C

4. Quick Check:

   soft reset = keep staged changes [OK]

Hint: Soft reset keeps changes staged for quick recommit [OK]

Common Mistakes:

• Confusing soft with mixed reset
• Thinking soft deletes changes
• Assuming soft unstages changes

2. Which of the following is the correct syntax to undo the last commit but keep changes unstaged?

easy

A. git reset --keep HEAD~1

B. git reset --soft HEAD~1

C. git reset --hard HEAD~1

D. git reset --mixed HEAD~1

Solution

1. Step 1: Identify the reset option for unstaging changes

   The --mixed option resets the commit and unstages changes but keeps them in the folder.

2. Step 2: Verify syntax correctness

   All commands use HEAD~1 to move one commit back; --mixed is the default and correct option here.

3. Final Answer:

   git reset --mixed HEAD~1 -> Option D

4. Quick Check:

   mixed reset = unstage but keep changes [OK]

Hint: Mixed reset unstages but keeps changes in folder [OK]

Common Mistakes:

• Using --soft when unstaging is needed
• Using --hard which deletes changes
• Using invalid --keep option

3. Given you committed changes but want to undo the commit and remove all changes from your working folder, what will be the result of git reset --hard HEAD~1?

medium

A. The commit is undone, changes remain staged.

B. The commit is undone, changes are deleted from folder and staging.

C. The commit is undone, changes remain unstaged in folder.

D. The commit is undone, changes are saved in stash.

Solution

1. Step 1: Understand --hard reset effect

   This option resets the commit and deletes all changes from both staging and working folder.

2. Step 2: Confirm no changes remain

   After hard reset, the working folder matches the commit pointed by HEAD, so changes are lost.

3. Final Answer:

   The commit is undone, changes are deleted from folder and staging. -> Option B

4. Quick Check:

   hard reset = delete changes from folder and staging [OK]

Hint: Hard reset deletes changes from folder and staging [OK]

Common Mistakes:

• Thinking hard reset keeps changes staged
• Confusing hard with mixed reset
• Assuming changes are saved in stash automatically

4. You ran git reset --soft HEAD~1 but your changes disappeared from staging. What is the likely cause?

medium

A. You ran git reset --mixed instead of soft.

B. You committed new changes after reset.

C. Your Git version does not support --soft option.

D. You actually ran git reset --hard by mistake.

Solution

1. Step 1: Analyze why changes are unstaged

   Soft reset keeps changes staged; if changes disappeared from staging, mixed reset was likely used.

2. Step 2: Check command confusion

   Mixed reset unstages changes but keeps them in folder, matching the symptom.

3. Final Answer:

   You ran git reset --mixed instead of soft. -> Option A

4. Quick Check:

   Mixed reset unstages changes, soft keeps staged [OK]

Hint: Unstaged changes? Check if mixed reset was used instead of soft [OK]

Common Mistakes:

• Confusing soft and mixed reset effects
• Assuming Git version lacks --soft support
• Thinking reset deletes changes automatically

5. You committed changes but realize you want to undo the commit, keep the changes unstaged, and then selectively stage some files. Which command sequence achieves this?

hard

A. git reset --mixed HEAD~1; git add <files>

B. git reset --soft HEAD~1; git add <files>

C. git reset --hard HEAD~1; git add <files>

D. git reset --soft HEAD~1; git reset HEAD <files>

Solution

1. Step 1: Undo commit and unstage changes

   git reset --mixed HEAD~1 moves HEAD back, unstages changes but keeps them in folder.

2. Step 2: Selectively stage files

   Use git add <files> to stage only desired files after unstaging.

3. Final Answer:

   git reset --mixed HEAD~1; git add <files> -> Option A

4. Quick Check:

   Mixed reset + selective add stages chosen files [OK]

Hint: Use mixed reset to unstage, then add files selectively [OK]

Common Mistakes:

• Using soft reset which keeps all changes staged
• Using hard reset which deletes changes
• Trying to unstage files after soft reset