Modify Specific Git Commits: Complete Guide

To modify a specific commit like HEAD~3 in Git, you’ll need to use interactive rebase to reapply commits from that point forward, allowing you to edit, reorder, or delete commits. The most common approach is git rebase -i HEAD~3 which opens an editor where you can mark the specific commit for editing (using ‘reword’, ‘edit’, or ‘pick’ commands), then amend the commit during the rebase process.

Contents

• Understanding Commit Modification Basics
• Interactive Rebase Method
• Cherry-Pick Alternative
• Reset and Recommit Approach
• Best Practices and Considerations
• Troubleshooting Common Issues

Understanding Commit Modification Basics

Modifying historical commits in Git is possible but requires careful consideration because it changes the commit history, which can affect collaborators. Unlike git commit --amend which only modifies the most recent commit, changing older commits requires rewriting history from that point forward.

When you modify a commit, you’re essentially creating a new commit with the same content but different metadata (author, date, message) or different content altogether. The original commit remains in the history until you force push and others have pulled your changes.

Key concepts to understand:

• Rewriting history: This changes the commit hashes and creates new commits
• Detached HEAD state: Some operations temporarily put you in this state
• Force pushing: Required to share modified history with others
• Interactive rebase: The primary tool for modifying multiple commits

Important: Always back up your work before modifying history, and avoid force pushing to shared repositories unless absolutely necessary.

Interactive Rebase Method

The interactive rebase method is the most flexible and commonly used approach for modifying specific commits. Here’s how to modify HEAD~3:

# Start interactive rebase 3 commits back
git rebase -i HEAD~3

This command opens your default text editor with a file showing the commits you’re about to reapply:

pick a1b2c3d Initial commit
pick d4e5f6g Add feature X
pick h7i8j9k Fix bug in feature X
# Rebase 123..456 onto 123 (3 commands)
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label this HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to re-use the original merge
# .       commit's author and message.
#
# These lines can be re-ordered; they are executed from top to bottom.

To modify the third commit (HEAD~3 in your original history), change ‘pick’ to ‘edit’ (or just ‘e’):

pick a1b2c3d Initial commit
pick d4e5f6g Add feature X
edit h7i8j9k Fix bug in feature X

Save and close the editor. Git will stop at that commit, leaving you in a detached HEAD state. Now you can amend the commit:

# Make your changes to the files
git add .  # or specific files

# Amend the commit with new changes or message
git commit --amend

# Or to only change the commit message:
git commit --amend --no-edit

# Continue the rebase
git rebase --continue

If you need to modify multiple commits, you can mark several with ‘edit’ and amend them one by one.

Cherry-Pick Alternative

For cases where you only need to apply changes from one commit to another branch, cherry-pick can be useful:

# Create a new branch from the commit before the one you want to modify
git checkout -b temp-branch HEAD~4

# Cherry-pick the commit you want to modify
git cherry-pick HEAD~3

# Now modify the cherry-picked commit
git commit --amend

# Checkout your original branch and merge the changes
git checkout main
git merge temp-branch

# Clean up the temporary branch
git branch -d temp-branch

This approach is less efficient for modifying existing commits in-place but can be useful for applying specific changes to different branches.

Reset and Recommit Approach

For more radical changes, you can reset to before the commit and recommit:

# Reset to before the commit you want to modify
git reset --soft HEAD~4

# Make your changes
git add .

# Commit with new changes
git commit -m "New commit message"

# If you need to preserve the original commit message
git commit -m "$(git log --format=%B -n 1 HEAD~3)"

The --soft reset keeps your changes staged but doesn’t destroy them. Use --hard only if you’re sure you want to discard all changes since the reset point.

Best Practices and Considerations

When modifying commits:

• Always work on a local branch first
• Consider creating a backup branch before starting
• Test your changes thoroughly after modifying history
• Communicate with your team if you’ll be force pushing

Force pushing considerations:

# Safe force push (rejects if remote has diverged)
git push --force-with-lease origin your-branch

# More aggressive force push
git push --force origin your-branch

Collaboration guidelines:

• Never force push to shared branches unless all collaborators are aware
• Consider using git push --force-with-lease as a safer alternative
• Document major history rewrites for your team

Troubleshooting Common Issues

Conflicts during rebase:

# Resolve conflicts in your files
git add resolved-file.txt

# Continue the rebase
git rebase --continue

# Or abort if you can't resolve
git rebase --abort

Detached HEAD state:

# Check your current HEAD
git status

# Return to your branch
git checkout your-branch-name

Accidental force push:

# Recover lost commits
git reflog
git reset --hard HEAD@{5}  # or appropriate reflog entry

Undoing a rebase:

# If you haven't force pushed yet
git rebase --abort

# Or reset to the original branch state
git reset --hard original-branch-point

Sources

1. Git Documentation - Interactive Rewriting
2. Atlassian Git Tutorial - Rewriting History
3. Pro Git Book - Interactive Rebasing
4. GitHub Documentation - Rebasing

Conclusion

Modifying specific commits in Git requires understanding interactive rebase and the implications of rewriting history. For your case with HEAD~3, using git rebase -i HEAD~3 and marking the commit with ‘edit’ is the most direct approach. Always remember to test your changes, communicate with collaborators when necessary, and consider creating backups before major history rewrites. The key is to work methodically, resolve any conflicts that arise, and verify your final state before sharing the modified history.