npx skills add https://github.com/wshobson/agents --skill git-advanced-workflowsHow 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.
Pre-configured AI company — 18 agents, 18 skills, one-time purchase.
SKILL.md396 linesExpandCollapse
---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```Accessibility Compliance
This walks you through implementing proper WCAG 2.2 compliance with real code patterns for screen readers, keyboard navigation, and mobile accessibility. It cov
Airflow Dag Patterns
If you're building data pipelines with Airflow, this skill gives you production-ready DAG patterns that actually work in the real world. It covers TaskFlow API
Angular Migration
Migrating from AngularJS to Angular is notoriously painful, and this skill tackles the practical stuff that makes or breaks these projects. It covers hybrid app