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

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

LICENSE

MIT License

Copyright (c) 2024 Seth Hobson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. 

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