Skill v1.0.1
currentAutomated scan100/100+4 new
name: git-advanced-workflows description: "Master advanced Git techniques to maintain clean history, collaborate effectively, and recover from any situation with confidence." risk: critical source: community date_added: "2026-02-27" metadata: version: "1.0.1"
Git Advanced Workflows
Master advanced Git techniques to maintain clean history, collaborate effectively, and recover from any situation with confidence.
Do not use this skill when
- The task is unrelated to git advanced workflows
- You need a different domain or tool outside this scope
Instructions
- Clarify goals, constraints, and required inputs.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
When to Use
- Cleaning up commit history before merging
- Applying specific commits across branches
- Finding commits that introduced bugs
- Working on multiple features simultaneously
- Recovering from Git mistakes or lost commits
- Managing complex branch workflows
- Preparing clean PRs for review
- Synchronizing diverged branches
Repository and Recovery Boundary
Read repository instructions and branch protection first. A hotfix follows the protected PR/maintainer path when required; urgency does not authorize a direct default-branch commit or push. Preserve dirty and staged work before checkout, rebase, reset or restore. A backup branch protects committed history only, not uncommitted files. Inspect exact targets before destructive operations and obtain authorization for shared-history rewrites. Reflog availability depends on local expiry and garbage collection; it cannot guarantee recovery of every lost file.
Core Concepts
1. Interactive Rebase
Interactive rebase is the Swiss Army knife of Git history editing.
Common Operations:
pick: Keep commit as-isreword: Change commit messageedit: Amend commit contentsquash: Combine with previous commitfixup: Like squash but discard messagedrop: Remove commit entirely
Basic Usage:
# Rebase last 5 commitsgit rebase -i HEAD~5# Rebase all commits on current branchgit rebase -i $(git merge-base HEAD main)# Rebase onto specific commitgit rebase -i abc123
2. Cherry-Picking
Apply specific commits from one branch to another without merging entire branches.
# Cherry-pick single commitgit cherry-pick abc123# Cherry-pick range of commits (exclusive start)git cherry-pick abc123..def456# Cherry-pick without committing (stage changes only)git cherry-pick -n abc123# Cherry-pick and edit commit messagegit cherry-pick -e abc123
3. Git Bisect
Binary search through commit history to find the commit that introduced a bug.
# Start bisectgit bisect start# Mark current commit as badgit bisect bad# Mark known good commitgit bisect good v1.0.0# Git will checkout middle commit - test it# Then mark as good or badgit bisect good # or: git bisect bad# Continue until bug found# When donegit bisect reset
Automated Bisect:
# Use script to test automaticallygit bisect start HEAD v1.0.0git bisect run ./test.sh# test.sh should exit 0 for good, 1-127 (except 125) for bad
4. Worktrees
Work on multiple branches simultaneously without stashing or switching.
# List existing worktreesgit worktree list# Add new worktree for feature branchgit worktree add ../project-feature feature/new-feature# Add worktree and create new branchgit worktree add -b bugfix/urgent ../project-hotfix main# Remove worktreegit worktree remove ../project-feature# Prune stale worktreesgit worktree prune
5. Reflog
Your safety net - tracks all ref movements, even deleted commits.
# View refloggit reflog# View reflog for specific branchgit reflog show feature/branch# Restore deleted commitgit reflog# Find commit hashgit checkout abc123git branch recovered-branch# Restore deleted branchgit refloggit branch deleted-branch abc123
Practical Workflows
Workflow 1: Clean Up Feature Branch Before PR
# Start with feature branchgit checkout feature/user-auth# Interactive rebase to clean historygit rebase -i main# Example rebase operations:# - Squash "fix typo" commits# - Reword commit messages for clarity# - Reorder commits logically# - Drop unnecessary commits# Force push cleaned branch (safe if no one else is using it)git push --force-with-lease origin feature/user-auth
Workflow 2: Apply Hotfix to Multiple Releases
# Create fix on an authorized topic branch from the current targetgit fetch origin maingit switch -c hotfix/security origin/maingit commit -m "fix: critical security patch"# Apply to release branchesgit checkout release/2.0git cherry-pick abc123git checkout release/1.9git cherry-pick abc123# Handle conflicts if they arisegit cherry-pick --continue# orgit cherry-pick --abort
Workflow 3: Find Bug Introduction
# Start bisectgit bisect startgit bisect bad HEADgit bisect good v2.1.0# Git checks out middle commit - run testsnpm test# If tests failgit bisect bad# If tests passgit bisect good# Git will automatically checkout next commit to test# Repeat until bug found# Automated versiongit bisect start HEAD v2.1.0git bisect run npm test
Workflow 4: Multi-Branch Development
# Main project directorycd ~/projects/myapp# Create worktree for urgent bugfixgit worktree add ../myapp-hotfix hotfix/critical-bug# Work on hotfix in separate directorycd ../myapp-hotfix# Make changes, commitgit commit -m "fix: resolve critical bug"git push origin hotfix/critical-bug# Return to main work without interruptioncd ~/projects/myappgit fetch origingit cherry-pick hotfix/critical-bug# Clean up when donegit worktree remove ../myapp-hotfix
Workflow 5: Recover from Mistakes
# Accidentally reset to wrong commit# Historical incident: a hard reset discarded local work; do not reproduce it.# Use reflog to find lost commitsgit reflog# Output shows:# abc123 HEAD@{0}: reset: moving to HEAD~5# def456 HEAD@{1}: commit: my important changes# Preserve the located commit for inspection firstgit branch recovered-commit def456# Reset only after saving dirty work and authorizing its loss# git reset --hard def456# Or create branch from lost commitgit branch recovery def456
Advanced Techniques
Rebase vs Merge Strategy
When to Rebase:
- Cleaning up local commits before pushing
- Keeping feature branch up-to-date with main
- Creating linear history for easier review
When to Merge:
- Integrating completed features into main
- Preserving exact history of collaboration
- Public branches used by others
# Update feature branch with main changes (rebase)git checkout feature/my-featuregit fetch origingit rebase origin/main# Handle conflictsgit status# Fix conflicts in filesgit add <resolved-paths>git rebase --continue# Or merge insteadgit merge origin/main
Autosquash Workflow
Automatically squash fixup commits during rebase.
# Make initial commitgit commit -m "feat: add user authentication"# Later, fix something in that commit# Stage changesgit commit --fixup HEAD # or specify commit hash# Make more changesgit commit --fixup abc123# Rebase with autosquashgit rebase -i --autosquash main# Git automatically marks fixup commits
Split Commit
Break one commit into multiple logical commits.
# Start interactive rebasegit rebase -i HEAD~3# Mark commit to split with 'edit'# Git will stop at that commit# Reset commit but keep changesgit reset HEAD^# Stage and commit in logical chunksgit add file1.pygit commit -m "feat: add validation"git add file2.pygit commit -m "feat: add error handling"# Continue rebasegit rebase --continue
Partial Cherry-Pick
Cherry-pick only specific files from a commit.
# Show files in commitgit show --name-only abc123# Checkout specific files from commitgit checkout abc123 -- path/to/file1.py path/to/file2.py# Stage and commitgit commit -m "cherry-pick: apply specific changes from abc123"
Best Practices
- Authorized Rewrites Only: Use an explicit expected remote SHA with a lease for an authorized topic-branch rewrite; a lease is not permission to rewrite shared history
- Rebase Only Local Commits: Don't rebase commits that have been pushed and shared
- Descriptive Commit Messages: Future you will thank present you
- Atomic Commits: Each commit should be a single logical change
- Test Before Force Push: Ensure history rewrite didn't break anything
- Keep Reflog Aware: Remember reflog is a local recovery aid with configurable expiry; unreachable entries may expire sooner
- Branch Before Risky Operations: Create backup branch before complex rebases
# Authorized topic rewrite only; verify the expected remote headgit push --force-with-lease origin feature/branch# Create backup before risky operationgit branch backup-branchgit rebase -i main# If something goes wrong, inspect the backup in a separate worktree firstgit worktree add --detach ../rebase-recovery backup-branch
Common Pitfalls
- Rebasing Public Branches: Causes history conflicts for collaborators
- Force Pushing Without Lease: Can overwrite teammate's work
- Losing Work in Rebase: Resolve conflicts carefully, test after rebase
- Forgetting Worktree Cleanup: Orphaned worktrees consume disk space
- Not Backing Up Before Experiment: Always create safety branch
- Bisect on Dirty Working Directory: Commit or stash before bisecting
Recovery Commands
# Abort operations in progressgit rebase --abortgit merge --abortgit cherry-pick --abortgit bisect reset# Restore file to version from specific commitgit restore --source=abc123 path/to/file# Undo last commit but keep changesgit reset --soft HEAD^# Undo last commit and discard changesgit reset --hard HEAD^# Recover deleted branch while the commit remains available locallygit refloggit branch recovered-branch abc123
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.