Claude Agent Skill · by Wshobson

Git Advanced Workflows

Master interactive rebasing, cherry-picking, bisect debugging, and worktrees without the fear of breaking your repository. Covers the practical workflows you ac

Install
Terminal · npx
$npx skills add https://github.com/wshobson/agents --skill git-advanced-workflows
Works with Paperclip

How Git Advanced Workflows fits into a Paperclip company.

Git Advanced Workflows drops into any Paperclip agent that handles this kind of work. Assign it to a specialist inside a pre-configured PaperclipOrg company and the skill becomes available on every heartbeat — no prompt engineering, no tool wiring.

S
SaaS FactoryPaired

Pre-configured AI company — 18 agents, 18 skills, one-time purchase.

$27$59
Explore pack
Source file
SKILL.md396 lines
Expand
---name: git-advanced-workflowsdescription: Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use when managing complex Git histories, collaborating on feature branches, or troubleshooting repository issues.--- # Git Advanced Workflows Master advanced Git techniques to maintain clean history, collaborate effectively, and recover from any situation with confidence. ## When to Use This Skill - 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 ## Core Concepts ### 1. Interactive Rebase Interactive rebase is the Swiss Army knife of Git history editing. **Common Operations:** - `pick`: Keep commit as-is- `reword`: Change commit message- `edit`: Amend commit content- `squash`: Combine with previous commit- `fixup`: Like squash but discard message- `drop`: Remove commit entirely **Basic Usage:** ```bash# 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. ```bash# 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. ```bash# 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:** ```bash# 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. ```bash# 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. ```bash# 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 ```bash# 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 ```bash# Create fix on maingit checkout maingit commit -m "fix: critical security patch" # Apply to release branchesgit checkout release/2.0git cherry-pick abc123 git checkout release/1.9git cherry-pick abc123 # Handle conflicts if they arisegit cherry-pick --continue# orgit cherry-pick --abort``` ### Workflow 3: Find Bug Introduction ```bash# 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 ```bash# 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 ```bash# Accidentally reset to wrong commitgit reset --hard HEAD~5  # Oh no! # Use reflog to find lost commitsgit reflog# Output shows:# abc123 HEAD@{0}: reset: moving to HEAD~5# def456 HEAD@{1}: commit: my important changes # Recover lost commitsgit 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 ```bash# 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 .git rebase --continue # Or merge insteadgit merge origin/main``` ### Autosquash Workflow Automatically squash fixup commits during rebase. ```bash# 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. ```bash# 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. ```bash# 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 1. **Always Use --force-with-lease**: Safer than --force, prevents overwriting others' work2. **Rebase Only Local Commits**: Don't rebase commits that have been pushed and shared3. **Descriptive Commit Messages**: Future you will thank present you4. **Atomic Commits**: Each commit should be a single logical change5. **Test Before Force Push**: Ensure history rewrite didn't break anything6. **Keep Reflog Aware**: Remember reflog is your safety net for 90 days7. **Branch Before Risky Operations**: Create backup branch before complex rebases ```bash# Safe force pushgit push --force-with-lease origin feature/branch # Create backup before risky operationgit branch backup-branchgit rebase -i main# If something goes wronggit reset --hard 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 ```bash# 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 (within 90 days)git refloggit branch recovered-branch abc123```