Git Advanced: Rebase, Bisect, and the Commands That Save Hours (2026)

#git #cli #productivity #tutorial

Git Advanced: Rebase, Bisect, and the Commands That Save Hours (2026)

Most developers know git commit and git push. But the real power of Git is in the commands that fix mistakes, untangle history, and save you hours of debugging.

Rebasing: Clean History, Every Time

# The golden rule: NEVER rebase pushed commits (shared history)
# Only rebase local commits that haven't been pushed yet!

# Interactive rebase — your most powerful tool:
git rebase -i HEAD~3    # Rebase last 3 commits
# Opens editor with these options for each commit:
#   pick  abc1234 Commit message 1
#   pick  def5678 Commit message 2
#   pick  ghi9012 Commit message 3

# Available actions:
#   pick (p) = use commit as-is
#   reword (r) = change commit message only
#   edit (e) = pause here to amend files or split commit
#   squash (s) = merge into previous commit (keep message)
#   fixup (f) = merge into previous commit (discard message)
#   drop (d) = remove this commit entirely

# Common rebase workflows:

# Squash last 3 "WIP" commits into one clean commit:
# Change first to "pick", rest to "squash"
# Save → Git opens editor with combined message

# Split a large commit into smaller ones:
git rebase -i HEAD~1
# Change "pick" to "edit" on target commit
# Git pauses at that commit:
git reset HEAD~1          # Unstage all files
git add feature-A.js && git commit -m "Add feature A"
git add feature-B.js && git commit -m "Add feature B"
git add feature-C.js && git commit -m "Add feature C"
git rebase --continue     # Continue rebasing

# Move a commit to a different position:
# In interactive rebase, reorder lines to change commit order!

# Fix a forgotten file in a previous commit:
git rebase -i HEAD~3
# Find the target commit → change to "edit"
# When git pauses: git add forgotten-file && git rebase --continue

# Update branch to match upstream (cleaner than merge):
git fetch origin main
git rebase origin/main    // Replays your commits on top of latest main
// Result: Linear history, no merge commits!

Bisect: Find the Breaking Commit in Minutes

# When did this bug appear? Don't guess — let git tell you!

git bisect start
git bisect bad              # Current version has the bug
git bisect good v2.0.0      # This version was working fine

# Git automatically checks out a middle commit.
# You test it, then:

git bisect good             # This version works → bug was introduced AFTER
git bisect bad              # This version is broken → bug was introduced BEFORE

# Repeat ~5-7 times (binary search halves the search space each time!)
# Git tells you exactly which commit introduced the bug:
# abc1234 is the first bad commit
# commit message: "Refactored auth module"

git bisect reset            # Done — return to original branch

# For automated testing (scriptable bisect):
git bisect start
git bisect bad HEAD
git bisect good v2.0.0
git bisect run npm test      # Runs test command automatically at each step!
# Output: abc1234 is the first bad commit (after N tests)

# Pro tip: Use bisect for ANY regression, not just code bugs:
# - Performance regression (bisect + benchmark script)
# - Build breakage (bisect + compile check)
# - Test failure (bisect + specific test)

Stash: Save Work Without Committing

# Basic stash (saves tracked files only):
git stash                    # Stashes everything with default message
git stash push -m "WIP: OAuth login half-done"  # Named stash

# See what's stashed:
git stash list
# stash@{0}: On feature/auth: WIP: OAuth login half-done
# stash@{1}: On main: Quick experiment

# Restore stashed changes:
git stash pop               # Apply AND remove from stash list
git stash apply             # Apply BUT keep in stash list (safer)
git stash apply stash@{1}   # Restore a specific stash

# Stash specific files only:
git stash push -m "Config changes" src/config.js .env.example

# Include untracked AND ignored files:
git stash push -u -m "Everything"     # Includes new untracked files
git stash push -a -m "Really everything"  // Even ignored files!

# Show what changed in a stash:
git stash show -p stash@{0}   // Full diff of the stash

# Drop or clear:
git stash drop stash@{0}     // Remove one
git stash clear              // Remove ALL stashes

# Create a branch from a stash:
git stash branch fix-quick-bug stash@{0}
// Creates new branch "fix-quick-bug", applies stash, drops it if successful

Searching Through History

# Search COMMIT MESSAGES across all branches:
git log --all --grep="security" --oneline
git log --all --grep="fix" --grep="auth" --oneline  --and  (both words)
git log --all --grep="fix\|bug" --oneline       --or  (either word)

# Search CODE CONTENT through entire history:
git log -S "functionName" --oneline    // When text was added/removed
git log -G "pattern" --oneline         // Regex through diffs
git log -S "TODO" -p                   // Show actual diff where text appears

# Who wrote/changed this line?
git blame src/utils.js                  // Line-by-line author history
git blame -L 10,20 src/utils.js        // Lines 10-20 only
git blame -e src/utils.js             // Include email addresses
git blame -w src/utils.js             // Ignore whitespace changes

# Find which commit broke something (alternative to bisect for simple cases):
git log --oneline --since="2 weeks ago" -- src/auth.js
git log --oneline --author="Alice" -- src/api/

Recovering from Mistakes

# ❌ Committed to wrong branch:
git reset --soft HEAD~1        # Undo commit, keep changes staged
git checkout correct-branch
git commit                     # Re-commit on correct branch

# ❌ Accidentally committed sensitive data:
# If NOT pushed:
git rm secrets.json
git commit -m "Remove secrets"
# If already pushed: use BFG Repo Cleaner or git filter-repo

# ❌ Need to undo something?
git restore file.txt            // Discard uncommitted working directory changes
git restore --staged file.txt   // Unstage (keep changes)
git reflog                      // Recovery mode: find lost commits!

# Recover a deleted branch:
git reflog                       # Find SHA of branch tip
git branch recovered-branch abc1234

# Reset types explained:
git reset --soft HEAD~1   // Undo commit, keep changes STAGED
git reset --mixed HEAD~1   // Undo commit, keep changes UNSTAGED (default)
git reset --hard HEAD~1    // Undo commit, DISCARD all changes (dangerous!)

# Undo a specific file's changes to previous commit state:
git checkout HEAD~1 -- file.txt  // Get version from previous commit
// Or: git restore --source=HEAD~1 file.txt