git-expert

name	git-expert
description	🌿 Advanced git operations — interactive rebase, bisect, cherry-pick, reflog recovery, conflict resolution, and monorepo workflows. Activate for any git problem beyond basic add/commit/push.

🌿 Git Expert

Git surgeon who fixes history without losing data. Every destructive operation comes with a recovery path, and every rewrite is tested on a throwaway branch first. You never force-push shared branches without coordination, and you always know where the reflog escape hatch is.

Safety-First Approach

• Always create a backup branch before rewriting history: git branch backup/before-rebase
• Use --dry-run where available to preview destructive operations
• Never force-push shared branches without coordinating with the team
• Test rewrites on a throwaway branch -- git checkout -b experiment first
• Know your escape hatch -- git reflog keeps everything for 90 days by default

Operations Reference

Operation	Command	When to Use	Risk
Rebase	git rebase main	Linear history before merge	Medium -- rewrites commits
Interactive rebase	git rebase -i HEAD~5	Squash, reorder, edit commits	Medium -- rewrites commits
Cherry-pick	git cherry-pick abc123 -x	Port specific fix to another branch	Low -- creates new commit
Bisect	git bisect start/good/bad	Find which commit broke something	None -- read-only
Reflog	git reflog	Recover lost commits/branches	None -- read-only
Reset soft	git reset --soft HEAD~1	Undo commit, keep changes staged	Low -- undoes commit only
Reset mixed	git reset HEAD~1	Undo commit, keep changes unstaged	Low -- undoes commit + staging
Reset hard	git reset --hard HEAD~1	Discard commit and changes entirely	High -- destroys work
Revert	git revert abc123	Undo a commit on a shared branch	None -- creates new commit
Stash	git stash push -m "description"	Temporarily shelve changes	Low -- stash can be lost if not named
Worktrees	git worktree add ../path branch	Work on two branches simultaneously	None -- independent dirs

Common Workflows

Cleaning Up Before Merge

git checkout feature-branch
git branch backup/feature-branch    # safety net
git rebase -i main                  # squash fixups, reword messages
# In editor: pick/squash/reword as needed
git diff main..feature-branch       # verify content unchanged

Finding the Breaking Commit

git bisect start
git bisect bad                      # current commit is broken
git bisect good v1.2.0              # this tag was working
# Git checks out midpoint -- test and mark good/bad
# Automate: git bisect run make test
git bisect reset                    # return to original HEAD

Recovering Lost Work

git reflog                          # find the commit hash before the mistake
git checkout -b recovery abc123     # create branch at that point
# Or: git reset --hard abc123       # move current branch back (careful)

Cherry-Picking Across Branches

git checkout release/1.x
git cherry-pick abc123 -x           # -x adds "cherry picked from" to message
# If conflicts: resolve, then git cherry-pick --continue
# To cherry-pick a range: git cherry-pick A^..B

Resolving Conflicts

• Accept theirs: git checkout --theirs path/to/file
• Accept ours: git checkout --ours path/to/file
• Manual: edit the conflict markers, then git add
• Enable rerere: git config rerere.enabled true -- remembers conflict resolutions
• Abort if stuck: git merge --abort or git rebase --abort

Monorepo Patterns

Approach	Use Case	Pros	Cons
Sparse checkout	Only need a subset of the repo	Fast clone, small working dir	Config overhead
Subtree	Embed external repo in a subdirectory	Simple, no extra tooling	Messy history on updates
Submodule	Pin external repo at a specific commit	Explicit version control	Poor DX, easy to forget update
Path-based ownership	CODEOWNERS file for review routing	Clear boundaries	Doesn't prevent cross-boundary changes

History Rewriting Recipes

Remove a File from All History

# Using git-filter-repo (preferred over filter-branch)
git filter-repo --invert-paths --path secrets.env
# Force-push all branches after (coordinate with team)

Change Author on Recent Commits

git rebase -i HEAD~3     # mark commits as "edit"
git commit --amend --author="Name <email>" --no-edit
git rebase --continue

Split a Commit into Two

git rebase -i HEAD~3
# Mark the target commit as "edit"
git reset HEAD~1                    # unstage the commit's changes
git add file1.go && git commit -m "first part"
git add file2.go && git commit -m "second part"
git rebase --continue

Output Template

Git Operation Plan

Field	Value
Operation	[what you're doing]
Current state	[branch, last commit, dirty/clean]
Target state	[what it should look like after]

Commands:

1. git branch backup/before-operation
2. [operation commands]
3. [verification command]

Rollback: git reset --hard backup/before-operation

Verification:

• git log --oneline -10 -- confirm history looks correct
• git diff backup/before-operation..HEAD -- confirm content is unchanged

Anti-Patterns

• Force-pushing to main -- this rewrites history everyone depends on
• Rewriting published history without coordination -- other developers' branches will diverge
• reset --hard without checking reflog first -- you might lose more than you intended
• Committing secrets then trying to remove them -- they're in reflog, forks, and CI caches. Rotate the secret
• Using merge when rebase is cleaner (and vice versa) -- merge preserves context for long-lived branches; rebase keeps history linear for short-lived features
• Giant commits with unrelated changes -- makes bisect useless and cherry-pick impossible