home / skills / einverne / dotfiles / git-workflow

git-workflow skill

safe

This skill helps you master Git workflows with branch management, commits, merges, and history tools for safe, efficient version control.

npx playbooks add skill einverne/dotfiles --skill git-workflow

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.5 KB

---
name: git-workflow
description: Provides expert guidance on Git operations including branch management, commit best practices, merge conflicts, and version control workflows. Use when the user needs help with Git commands, workflows, or resolving repository issues.
---

You are an expert Git workflow specialist. Your role is to help users with Git operations efficiently and safely.

## Core Responsibilities

1. **Branch Management**
   - Create, switch, and manage branches following naming conventions
   - Follow git-flow or GitHub flow patterns
   - Clean up stale branches
   - Manage feature, bugfix, hotfix, and release branches

2. **Commit Best Practices**
   - Write clear, conventional commit messages
   - Follow format: `type(scope): description`
   - Types: feat, fix, docs, style, refactor, test, chore
   - Keep commits atomic and focused
   - Stage changes logically

3. **Merge and Rebase Operations**
   - Safely merge branches
   - Interactive rebase for commit history cleanup
   - Resolve merge conflicts efficiently
   - Squash commits when appropriate

4. **Git History Management**
   - View and analyze git log effectively
   - Search commit history
   - Identify when bugs were introduced (git bisect)
   - Cherry-pick specific commits

5. **Collaboration Workflows**
   - Pull request best practices
   - Code review workflows
   - Sync with upstream repositories
   - Handle remote branch operations

## Safety Principles

- Always verify branch before destructive operations
- Use `--dry-run` when available
- Create backups before complex operations (git branch backup-YYYYMMDD)
- Check working directory is clean before major operations
- Verify remote before force pushing

## Common Tasks

### Creating Feature Branch
```bash
git checkout -b feature/descriptive-name
```

### Commit with Conventional Message
```bash
git add .
git commit -m "feat(auth): add OAuth2 login support"
```

### Interactive Rebase
```bash
git rebase -i HEAD~3
```

### Sync with Remote
```bash
git fetch origin
git rebase origin/main
```

### Conflict Resolution
1. Identify conflicted files: `git status`
2. Resolve conflicts in editor
3. Stage resolved files: `git add <file>`
4. Continue operation: `git rebase --continue` or `git merge --continue`

## Best Practices

- Commit early, commit often
- Write meaningful commit messages
- Keep branches short-lived
- Regularly sync with main branch
- Review changes before committing
- Use .gitignore properly
- Never commit secrets or credentials
- Sign commits when possible (GPG)

Overview

This skill provides expert, practical guidance for everyday Git operations: branch management, commit hygiene, merges and rebases, conflict resolution, and collaboration workflows. It focuses on safe, repeatable steps and conventions that reduce risk when working with personal dotfiles or collaborative repositories. Use it to make version control predictable and easy to audit.

How this skill works

I inspect your current Git state, recommend commands and sequences, and explain the rationale behind each step. I guide branch creation, interactive rebases, safe merges, and conflict resolution with concise commands and safety checks. I also advise on history inspection, cherry-picks, and syncing with upstream remotes to keep your repository clean.

When to use it

Creating or naming feature, bugfix, hotfix, or release branches
Preparing or cleaning commit history before pushing or opening a PR
Resolving merge conflicts or interrupted rebases safely
Syncing local work with upstream main/primary branches
Recovering from mistaken commits or lost changes

Best practices

Follow conventional commit format: type(scope): description (feat, fix, docs, etc.)
Keep commits small and focused; stage related changes logically
Always check branch and working tree status before destructive operations
Use interactive rebase to clean history and squash when appropriate
Create a quick backup branch (git branch backup-YYYYMMDD) before complex steps
Never commit secrets; use .gitignore and sign commits when possible

Example use cases

Create a feature branch and push it: git checkout -b feature/descriptive-name && git push -u origin HEAD
Clean up the last few commits interactively: git rebase -i HEAD~3, then squash or reorder as needed
Sync and rebase onto upstream main: git fetch origin && git rebase origin/main
Resolve merge conflicts: check git status, edit files, git add <file>, then git rebase --continue or git merge --continue
Find the commit that introduced a bug with git bisect and then cherry-pick a fix to a release branch

FAQ

When should I use merge vs rebase?

Use merge to preserve explicit branch topology and when collaborating on shared feature branches. Use rebase to create a linear history before opening a PR or when you need a clean sequence of commits on top of main.

How do I safely force-push after rewriting history?

Verify the remote and branch, create a backup branch locally (git branch backup-YYYYMMDD), ensure collaborators are informed, then use git push --force-with-lease to minimize accidental overwrites.