Git Rebase Strategies and Best Practices

Git rebase rewrites commit history for cleaner, more linear projects. Here's how to use it effectively and safely.

Understanding Rebase#

# Basic rebase: Move branch to new base
git checkout feature
git rebase main

# Before rebase:
#    A---B---C feature
#   /
# D---E---F---G main

# After rebase:
#              A'--B'--C' feature
#             /
# D---E---F---G main

# Rebase creates new commits (A', B', C') with different hashes

Interactive Rebase#

# Rebase last 3 commits interactively
git rebase -i HEAD~3

# Rebase all commits since branching from main
git rebase -i main

# Interactive rebase opens editor with:
# pick abc123 First commit
# pick def456 Second commit
# pick ghi789 Third commit

# Available commands:
# pick   = use commit
# reword = edit commit message
# edit   = stop for amending
# squash = meld into previous commit (keep message)
# fixup  = meld into previous commit (discard message)
# drop   = remove commit

# Example: Squash last 3 commits into one
# pick abc123 First commit
# squash def456 Second commit
# squash ghi789 Third commit

# Example: Reorder and edit
# pick def456 Second commit (now first)
# reword ghi789 Third commit (edit message)
# drop abc123 First commit (removed)

Common Rebase Workflows#

# Keep feature branch up to date with main
git checkout feature
git fetch origin
git rebase origin/main

# Squash all branch commits before merge
git checkout feature
git rebase -i main
# Then squash all commits except the first

# Fixup a specific commit
git commit --fixup abc123
git rebase -i --autosquash main

# Autosquash automatically orders fixup commits
# Original:
# pick abc123 Original commit
# pick def456 Some other commit
# fixup xyz789 fixup! Original commit

# After autosquash reorders:
# pick abc123 Original commit
# fixup xyz789 fixup! Original commit
# pick def456 Some other commit

Handling Conflicts#

# During rebase, if conflicts occur:
git status  # See conflicting files

# Edit files to resolve conflicts
# Remove conflict markers (<<<<<<<, =======, >>>>>>>)

# Mark as resolved
git add <resolved-files>

# Continue rebase
git rebase --continue

# Or abort and return to pre-rebase state
git rebase --abort

# Skip this commit if not needed
git rebase --skip

# Use merge strategy for specific files
git checkout --ours <file>    # Keep current branch version
git checkout --theirs <file>  # Keep incoming version

Rebase vs Merge#

# Merge: Preserves history, creates merge commit
git checkout main
git merge feature

# Creates:
#    A---B---C feature
#   /         \
# D---E---F---G---H main (H is merge commit)

# Rebase: Linear history, rewrites commits
git checkout feature
git rebase main
git checkout main
git merge feature  # Fast-forward merge

# Creates:
# D---E---F---G---A'--B'--C' main

# When to use merge:
# - Public/shared branches
# - Preserving complete history
# - Collaborative branches

# When to use rebase:
# - Personal feature branches
# - Clean, linear history
# - Before merging to main

Safe Rebasing Practices#

# Golden rule: Never rebase public/shared commits

# Create backup before risky rebase
git branch backup-feature feature

# Use reflog to recover from mistakes
git reflog
# abc123 HEAD@{0}: rebase finished
# def456 HEAD@{1}: rebase: First commit
# ghi789 HEAD@{2}: checkout: moving from main to feature

git reset --hard ghi789  # Restore to before rebase

# Force push after rebase (only your branches!)
git push --force-with-lease origin feature

# --force-with-lease is safer than --force
# It fails if remote has commits you don't have

Advanced Rebase Operations#

# Rebase onto specific commit
git rebase --onto main feature~3 feature
# Rebases only last 3 commits of feature onto main

# Split a commit
git rebase -i HEAD~3
# Mark commit as "edit"
# When rebase stops at that commit:
git reset HEAD~1
git add file1.js
git commit -m "First part"
git add file2.js
git commit -m "Second part"
git rebase --continue

# Rebase with merge commits
git rebase -i --rebase-merges main

# Execute command after each commit
git rebase -i --exec "npm test" main
# Runs tests after each rebased commit

# Preserve merge commits
git rebase -p main

Team Workflows#

# Feature branch workflow with rebase
# 1. Create feature branch
git checkout -b feature/new-thing main

# 2. Make commits
git commit -m "Add feature"

# 3. Before PR, update and clean up
git fetch origin
git rebase origin/main

# 4. Interactive rebase to squash/cleanup
git rebase -i origin/main

# 5. Force push (since we rebased)
git push --force-with-lease origin feature/new-thing

# 6. Create PR, get review

# 7. If main updated during review, rebase again
git fetch origin
git rebase origin/main
git push --force-with-lease origin feature/new-thing

# 8. Merge via PR (usually squash merge)

Git Configuration for Rebasing#

# Auto-setup remote tracking
git config --global push.default current
git config --global push.autoSetupRemote true

# Always use rebase when pulling
git config --global pull.rebase true

# Autosquash by default
git config --global rebase.autosquash true

# Auto-stash before rebase
git config --global rebase.autoStash true

# Show conflicts in 3-way diff
git config --global merge.conflictstyle diff3

# Use better diff algorithm
git config --global diff.algorithm histogram

Rebase Aliases#

# Useful aliases
git config --global alias.rb 'rebase'
git config --global alias.rbi 'rebase -i'
git config --global alias.rbc 'rebase --continue'
git config --global alias.rba 'rebase --abort'
git config --global alias.rbs 'rebase --skip'

# Rebase onto main
git config --global alias.rom 'rebase origin/main'

# Interactive rebase from main
git config --global alias.rbim 'rebase -i origin/main'

# Fixup last commit into previous
git config --global alias.fixup 'commit --fixup HEAD'

# Squash all commits since main
git config --global alias.squash '!git reset --soft $(git merge-base HEAD origin/main) && git commit'

Troubleshooting#

# Rebase stuck or confused
git rebase --abort
git reflog
git reset --hard HEAD@{n}

# Wrong commits rebased
git reflog
git reset --hard <commit-before-rebase>

# Conflicts on every commit
# Might be rebasing wrong way
git rebase --abort
# Check you're rebasing feature onto main, not main onto feature

# Lost commits after rebase
git reflog
# All commits are still there, find and checkout

# Accidentally pushed rebased commits
# If others have pulled, you need to coordinate
# They need to:
git fetch origin
git reset --hard origin/branch
# Or:
git pull --rebase origin branch

Best Practices#

Do:
✓ Rebase local/personal branches
✓ Clean up commits before PR
✓ Use --force-with-lease
✓ Create backup branches

Don't:
✗ Rebase public/shared branches
✗ Rebase after pushing to shared repo
✗ Use --force on main/master
✗ Rebase without understanding consequences

Workflow:
✓ Rebase feature onto main regularly
✓ Squash fixup commits
✓ Write meaningful commit messages
✓ Test after rebase

Git rebase creates cleaner history but requires care. Use it for personal branches before merging, always use --force-with-lease for pushing, and never rebase shared commits. Master interactive rebase for cleaning up commits before pull requests. When in doubt, merge is safer.