AutoGineer
Generated banner for Git Advanced Workflows
Generated logo for Git Advanced Workflows

Git Advanced Workflows

Seth HobsonCommunityCreated by Seth Hobson

  • Skill
  • Tool integration
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

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.
— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive guide to advanced Git operations designed to maintain clean project histories and resolve complex repository states. It covers powerful tools such as interactive rebasing, cherry-picking, binary search for bug isolation, multi-branch worktrees, and the reflog for disaster recovery. The content emphasizes best practices for safe history manipulation, including the use of force-with-lease and maintaining atomic commits, while providing practical workflows for real-world scenarios like hotfix distribution and accidental reset recovery.

What it does

  • Cleans up commit history using interactive rebasing and autosquash.
  • Isolates bugs by performing binary searches through commit history.
  • Manages multiple concurrent branches using worktrees without switching contexts.
  • Recovers lost commits or deleted branches using the reflog.
  • Applies specific changes across branches via cherry-picking.
  • Provides safe recovery procedures for common Git mistakes.

When to use it

  • When you need to clean up local commit history before merging a pull request.
  • When you need to find the specific commit that introduced a regression.
  • When you need to work on multiple features or hotfixes simultaneously.
  • When you have accidentally reset or deleted work and need to recover it.
  • When you need to apply a specific fix to multiple release branches.

Advantages

  • Enables a clean, linear project history for easier code review.
  • Provides a safety net for recovering from complex Git errors.
  • Increases developer productivity by enabling multi-tasking via worktrees.
  • Reduces time spent debugging by automating the search for bug-introducing commits.

Usage examples

“How can I clean up my last 5 commits before pushing to the main branch?”
The agent will guide you through an interactive rebase using 'git rebase -i HEAD~5', allowing you to squash, reword, or drop commits to create a clean history.
“I accidentally ran a hard reset and lost my work. How do I get it back?”
The agent will instruct you to use 'git reflog' to identify the lost commit hash and then create a new branch from that point to recover your changes.
“How do I find which commit broke the build in my project?”
The agent will explain how to use 'git bisect' to perform a binary search, marking commits as good or bad until the specific breaking commit is identified.
“I need to work on a hotfix but I am in the middle of a feature. What should I do?”
The agent will show you how to use 'git worktree' to create a separate directory for the hotfix branch, allowing you to work on it without stashing or switching your current branch.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/wshobson/git-advanced-workflows/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip git-advanced-workflows.zip -d .agents/skills

Documentation by Seth Hobson

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:

# Rebase last 5 commits
git rebase -i HEAD~5

# Rebase all commits on current branch
git rebase -i $(git merge-base HEAD main)

# Rebase onto specific commit
git rebase -i abc123
2. Cherry-Picking

Apply specific commits from one branch to another without merging entire branches.

# Cherry-pick single commit
git 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 message
git cherry-pick -e abc123
3. Git Bisect

Binary search through commit history to find the commit that introduced a bug.

# Start bisect
git bisect start

# Mark current commit as bad
git bisect bad

# Mark known good commit
git bisect good v1.0.0

# Git will checkout middle commit - test it
# Then mark as good or bad
git bisect good  # or: git bisect bad

# Continue until bug found
# When done
git bisect reset

Automated Bisect:

# Use script to test automatically
git bisect start HEAD v1.0.0
git 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 worktrees
git worktree list

# Add new worktree for feature branch
git worktree add ../project-feature feature/new-feature

# Add worktree and create new branch
git worktree add -b bugfix/urgent ../project-hotfix main

# Remove worktree
git worktree remove ../project-feature

# Prune stale worktrees
git worktree prune
5. Reflog

Your safety net - tracks all ref movements, even deleted commits.

# View reflog
git reflog

# View reflog for specific branch
git reflog show feature/branch

# Restore deleted commit
git reflog
# Find commit hash
git checkout abc123
git branch recovered-branch

# Restore deleted branch
git reflog
git branch deleted-branch abc123

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.

Best Practices

  1. Always Use --force-with-lease: Safer than --force, prevents overwriting others' work

  2. Rebase Only Local Commits: Don't rebase commits that have been pushed and shared

  3. Descriptive Commit Messages: Future you will thank present you

  4. Atomic Commits: Each commit should be a single logical change

  5. Test Before Force Push: Ensure history rewrite didn't break anything

  6. Keep Reflog Aware: Reflog is your safety net, but entries for commits not reachable from the current tip expire after 30 days by default (gc.reflogExpireUnreachable), and reachable entries after 90 days (gc.reflogExpire)

  7. Branch Before Risky Operations: Create backup branch before complex rebases

# Safe force push
git push --force-with-lease origin feature/branch

# Create backup before risky operation
git branch backup-branch
git rebase -i main
# If something goes wrong
git 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

# Abort operations in progress
git rebase --abort
git merge --abort
git cherry-pick --abort
git bisect reset

# Restore file to version from specific commit
git restore --source=abc123 path/to/file

# Undo last commit but keep changes
git reset --soft HEAD^

# Undo last commit and discard changes
# WARNING: --hard also deletes uncommitted changes (staged and unstaged),
# and the reflog cannot recover them. Check `git status` and stash first.
git reset --hard HEAD^

# Recover a deleted branch soon. By default, git gc can prune HEAD's reflog
# entries for unmerged commits once they're 30 days old, counted from when
# each entry was recorded, not from the deletion
# Deleting a branch also deletes its own reflog; search HEAD's reflog
git reflog
git branch recovered-branch abc123

Files

references/details.md

git-advanced-workflows — detailed patterns and worked examples

Practical Workflows

Workflow 1: Clean Up Feature Branch Before PR
# Start with feature branch
git checkout feature/user-auth

# Interactive rebase to clean history
git 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 main
git checkout main
git commit -m "fix: critical security patch"

# Apply to release branches
git checkout release/2.0
git cherry-pick abc123

git checkout release/1.9
git cherry-pick abc123

# Handle conflicts if they arise
git cherry-pick --continue
# or
git cherry-pick --abort
Workflow 3: Find Bug Introduction
# Start bisect
git bisect start
git bisect bad HEAD
git bisect good v2.1.0

# Git checks out middle commit - run tests
npm test

# If tests fail
git bisect bad

# If tests pass
git bisect good

# Git will automatically checkout next commit to test
# Repeat until bug found

# Automated version
git bisect start HEAD v2.1.0
git bisect run npm test
Workflow 4: Multi-Branch Development
# Main project directory
cd ~/projects/myapp

# Create worktree for urgent bugfix
git worktree add ../myapp-hotfix hotfix/critical-bug

# Work on hotfix in separate directory
cd ../myapp-hotfix
# Make changes, commit
git commit -m "fix: resolve critical bug"
git push origin hotfix/critical-bug

# Return to main work without interruption
cd ~/projects/myapp
git fetch origin
git cherry-pick hotfix/critical-bug

# Clean up when done
git worktree remove ../myapp-hotfix
Workflow 5: Recover from Mistakes
# Accidentally reset to wrong commit
git reset --hard HEAD~5  # Oh no!

# Use reflog to find lost commits
git reflog
# Output shows:
# abc123 HEAD@{0}: reset: moving to HEAD~5
# def456 HEAD@{1}: commit: my important changes

# Recover lost commits
git reset --hard def456

# Or create branch from lost commit
git 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-feature
git fetch origin
git rebase origin/main

# Handle conflicts
git status
# Fix conflicts in files
git add .
git rebase --continue

# Or merge instead
git merge origin/main
Autosquash Workflow

Automatically squash fixup commits during rebase.

# Make initial commit
git commit -m "feat: add user authentication"

# Later, fix something in that commit
# Stage changes
git commit --fixup HEAD  # or specify commit hash

# Make more changes
git commit --fixup abc123

# Rebase with autosquash
git rebase -i --autosquash main

# Git automatically marks fixup commits
Split Commit

Break one commit into multiple logical commits.

# Start interactive rebase
git rebase -i HEAD~3

# Mark commit to split with 'edit'
# Git will stop at that commit

# Reset commit but keep changes
git reset HEAD^

# Stage and commit in logical chunks
git add file1.py
git commit -m "feat: add validation"

git add file2.py
git commit -m "feat: add error handling"

# Continue rebase
git rebase --continue
Partial Cherry-Pick

Cherry-pick only specific files from a commit.

# Show files in commit
git show --name-only abc123

# Checkout specific files from commit
git checkout abc123 -- path/to/file1.py path/to/file2.py

# Stage and commit
git commit -m "cherry-pick: apply specific changes from abc123"

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs a command-line tool

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Seth Hobson
Publisher
Seth Hobson (Community)
Source
wshobson/agents · plugins/developer-essentials/skills/git-advanced-workflows · commit 4bde316
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Seth Hobson or Seth Hobson.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download git-advanced-workflows.zip