Skip to main content
skill CX Codex

managing-git — Claude Code skill: what it does, how to install

managing-git guides Claude Code through Git workflows, branch naming conventions, Conventional Commits formatting, and pull request review checklists.

MIT ★ 1,424 updated 2026-10-06

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add CloudAI-X/claude-workflow-v2
/plugin install project-starter@claude-workflow
Open on GitHub

What managing-git does

The skill sets structured Git practices for Claude Code: branch naming like <type>/<ticket-id>-<short-description>, Conventional Commits categorization (feat, fix, refactor), and PR sizing guidance from XS to L. It guides feature work through a six-step workflow from the initial branch creation to rebasing and merging.

It also bundles PR description templates, pre-push commit validation lists, and Git command snippets covering git bisect, stashing, and cherry-picking. In headless agent environments where git add -p or interactive rebasing cannot open an editor, the skill relies on git commit --fixup paired with non-interactive autosquash rebases.

What it helps with

  • format commits according to Conventional Commits specifications
  • name feature and bugfix branches with ticket identifiers
  • draft structured pull request descriptions with test verification checklists
  • clean up messy local commit history without an interactive terminal

Example prompts for the agent

  • Format an atomic commit for the updated auth endpoints using Conventional Commits.
  • Generate a PR summary for branch feature/AUTH-123-oauth-login.
  • Clean up the last three commits before pushing without interactive prompts.

How to install managing-git

1Plugin marketplace

/plugin marketplace add CloudAI-X/claude-workflow-v2
/plugin install project-starter@claude-workflow

This installs the whole project-starter plugin with all its skills

2Skills CLI (Vercel)

npx skills add CloudAI-X/claude-workflow-v2 --skill managing-git -a claude-code

3Manually: put the files in place

~/.claude/skills/managing-git/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/managing-git/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about managing-git

How to install managing-git in Claude Code?

Run /plugin marketplace add CloudAI-X/claude-workflow-v2 in Claude Code, then run /plugin install project-starter@claude-workflow.

What does managing-git do?

It provides checklists, branch naming rules, Conventional Commits standards, and command references for daily Git tasks and pull requests.

How does managing-git handle rebases without an interactive terminal?

It uses git commit --fixup=<sha> combined with GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash HEAD~3 to clean history automatically.

Source text

SKILL.md · MIT
---
name: managing-git
description: Manages Git workflows including branching, commits, and pull requests. Use when working with Git, creating commits, opening PRs, managing branches, resolving conflicts, or when asked about version control best practices.
---

# Managing Git

### When to Load

- **Trigger**: Branching strategies, commit workflows, pull requests, merge conflicts, version control questions
- **Skip**: Tasks that do not involve git operations

## Feature Development Workflow

Copy this checklist and track progress:

```
Feature Development Progress:
- [ ] Step 1: Create feature branch from main
- [ ] Step 2: Make changes with atomic commits
- [ ] Step 3: Rebase on latest main
- [ ] Step 4: Push and create PR
- [ ] Step 5: Address review feedback
- [ ] Step 6: Merge after approval
```

## Branching Strategies

### GitHub Flow (Recommended for most projects)

```
main ──●────●────●────●────●── (always deployable)
        \          /
feature  └──●──●──┘
```

- `main` is always deployable
- Feature branches from main
- PR + review + merge
- Deploy after merge

### Git Flow (For release-based projects)

```
main     ──●─────────────●────── (releases only)
            \           /
release      └────●────┘
                 /
develop  ──●──●────●──●──●──
            \     /
feature      └──●┘
```

## Commit Conventions

### Conventional Commits Format

```
<type>(<scope>): <description>

[optional body]

[optional footer(s)]
```

### Types

| Type       | Description                                         |
| ---------- | --------------------------------------------------- |
| `feat`     | New feature                                         |
| `fix`      | Bug fix                                             |
| `docs`     | Documentation only                                  |
| `style`    | Formatting, no logic change                         |
| `refactor` | Code change that neither fixes bug nor adds feature |
| `perf`     | Performance improvement                             |
| `test`     | Adding/updating tests                               |
| `chore`    | Build process, dependencies                         |
| `ci`       | CI configuration                                    |

### Examples

```bash
feat(auth): add OAuth2 login support

Implements Google and GitHub OAuth providers.
Closes #123

BREAKING CHANGE: Session tokens now expire after 24h
```

```bash
fix(api): handle null response from payment gateway

Previously caused 500 error when gateway returned null.
Now returns appropriate error message to user.
```

## Branch Naming

```
<type>/<ticket-id>-<short-description>

# Examples
feature/AUTH-123-oauth-login
fix/BUG-456-null-pointer
chore/TECH-789-upgrade-deps
```

## Pull Request Workflow

Copy this checklist when creating PRs:

```
PR Checklist:
- [ ] Code follows project conventions
- [ ] Tests added/updated for changes
- [ ] All tests pass locally
- [ ] No merge conflicts with main
- [ ] Documentation updated if needed
- [ ] No security vulnerabilities introduced
- [ ] PR description explains the "why"
```

### PR Template

```markdown
## Summary

[Brief description of changes]

## Changes

- [Change 1]
- [Change 2]

## Testing

- [ ] Unit tests added/updated
- [ ] Manual testing performed
- [ ] E2E tests pass

## Screenshots (if UI changes)

[Before/After screenshots]
```

### PR Size Guidelines

| Size | Lines Changed | Review Guidance   |
| ---- | ------------- | ----------------- |
| XS   | < 50          | Quick review      |
| S    | 50-200        | Standard review   |
| M    | 200-500       | Thorough review   |
| L    | 500+          | Split if possible |

## Common Git Commands

### Daily Workflow

```bash
# Start new feature
git checkout main
git pull
git checkout -b feature/TICKET-123-description

# Commit changes
git add path/to/file  # Stage specific files (git add -p needs an interactive terminal)
git commit -m "feat: description"

# Keep up with main
git fetch origin main
git rebase origin/main

# Push and create PR
git push -u origin HEAD  # after rebasing an already-pushed branch: git push --force-with-lease
```

### Fixing Mistakes

```bash
# Amend last commit (before push)
git commit --amend

# Undo last commit (keep changes)
git reset --soft HEAD~1

# Undo last commit (discard changes)
git reset --hard HEAD~1  # also discards uncommitted changes

# Revert a pushed commit
git revert <commit-hash>

# Interactive rebase to clean up
git rebase -i HEAD~3
# Non-interactive: git commit --fixup=<sha>, then
GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash HEAD~3
```

### Advanced Operations

```bash
# Cherry-pick specific commit
git cherry-pick <commit-hash>

# Find which commit broke something
git bisect start
git bisect bad HEAD
git bisect good <known-good-commit>

# Stash with message
git stash push -m "WIP: feature description"
git stash list
git stash pop
```

## Commit Validation

Before pushing, validate commits:

```
Commit Validation:
- [ ] Each commit has a clear, descriptive message
- [ ] Commit type matches the change (feat, fix, etc.)
- [ ] No WIP or temporary commits
- [ ] No secrets or credentials committed
- [ ] Changes are atomic (one logical change per commit)
```

If validation fails, use `git rebase -i` to clean up commit history (or `--fixup` + `--autosquash` when no interactive terminal is available) before pushing.

© CloudAI-X · MIT · CloudAI-X/claude-workflow-v2

Similar skills

All skills for Git and GitHub →

From the same set46

The whole set →
convex-backend convex-backend is a Claude Code skill that loads Convex guidelines for TypeScript functions, schemas, validators, queries, mutations, actions, subscriptions, and file storage. It supports type-safe backend development. CX Codex +1 ★ 1,424repo stars dependency-upgrade The dependency-upgrade command for Claude Code updates packages one by one, runs tests after each upgrade, and rolls back changes on failures. CX Codex +1 ★ 1,424repo stars designing-apis designing-apis — a Claude Code skill that designs REST and GraphQL APIs: structures endpoints, defines request and response formats, configures error handling and versioning. CX Codex +1 ★ 1,424repo stars parallel-analyze parallel-analyze starts four subagents at once: architecture, security, performance, testing. Their findings land in one report, ranked by priority. CX Codex +1 ★ 1,424repo stars code-reviewer code-reviewer — a Claude subagent that reads the changed files first, then reports findings by severity: correctness, security, performance, tests. CX Codex ★ 1,424repo stars designing-architecture designing-architecture — a skill that guides you through selecting an architecture pattern, evaluating project size and team capacity, and structuring your codebase. CX Codex +1 ★ 1,424repo stars optimizing-performance optimizing-performance guides performance profiling and tuning across frontend, backend, and database layers. It enforces measuring baselines before touching code and verifying against latency targets. CX Codex +1 ★ 1,424repo stars designing-tests designing-tests is a skill for planning test coverage, choosing test types, and investigating failures during test additions or testing-workflow setup. CX Codex +1 ★ 1,424repo stars

Project sponsors

Companies that keep this analytics open