PluginBench
Skill
Official
Pass
Audit score 90

git-commit

github/awesome-copilot

Execute semantic git commits with conventional message analysis and intelligent staging.

What is git-commit?

Automates git commits using the Conventional Commits specification. Analyzes diffs to detect change type and scope, generates standardized commit messages, and intelligently stages files for logical grouping. Use when committing changes, creating a git commit, or when the user mentions "/commit".

  • Auto-detect commit type (feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert) from diff analysis
  • Generate conventional commit messages with type, scope, and description from actual code changes
  • Support interactive commits with optional overrides for type, scope, and description
  • Intelligently stage files for logical grouping before committing
  • Handle breaking changes with exclamation mark notation or BREAKING CHANGE footer
  • Validate commit messages against Conventional Commits specification

How to install git-commit

npx skills add https://github.com/github/awesome-copilot --skill git-commit
Prerequisites
  • Git repository initialized locally
  • Bash shell access
Claude Code
Cursor
Windsurf
Cline

How to use git-commit

  1. 1.Run the skill when user requests a commit or mentions "/commit"
  2. 2.The skill analyzes staged or working tree changes using git diff
  3. 3.Review the auto-detected commit type and scope from the diff analysis
  4. 4.Optionally override the type, scope, or description if needed
  5. 5.The skill stages files intelligently if nothing is currently staged
  6. 6.Execute the commit with the generated conventional commit message

Use cases

Good for
  • Commit a new feature with auto-detected scope and message generation
  • Fix a bug and create a semantic commit message referencing the issue
  • Group related file changes into a single logical commit with intelligent staging
  • Create breaking change commits with proper footer notation
  • Commit documentation updates, refactors, or performance improvements with appropriate type classification
Who it's for
  • Developers using Conventional Commits in their projects
  • Teams enforcing semantic versioning and automated changelog generation
  • Engineers working with commit-based CI/CD pipelines
  • Anyone standardizing git history and commit message quality

git-commit FAQ

What if I want to stage only specific files?

The skill can stage files by path, pattern, or use interactive staging (git add -p) to group changes logically before committing.

How are commit types determined?

The skill analyzes the actual diff to determine the appropriate type: feat for new features, fix for bug fixes, docs for documentation, refactor for code restructuring, etc.

Can I create breaking change commits?

Yes. The skill supports breaking changes using an exclamation mark after the type/scope (e.g., feat!: remove endpoint) or a BREAKING CHANGE footer in the commit body.

What if the commit fails due to git hooks?

The skill will not skip hooks (--no-verify) unless explicitly requested. If a commit fails, fix the issues and create a new commit rather than amending.

Are there any safety restrictions?

Yes. The skill never updates git config, runs destructive commands without explicit request, or force pushes to main/master branches.

Full instructions (SKILL.md)

Source of truth, from github/awesome-copilot.


name: git-commit description: 'Execute git commit with conventional commit message analysis, intelligent staging, and message generation. Use when user asks to commit changes, create a git commit, or mentions "/commit". Supports: (1) Auto-detecting type and scope from changes, (2) Generating conventional commit messages from diff, (3) Interactive commit with optional type/scope/description overrides, (4) Intelligent file staging for logical grouping' license: MIT allowed-tools: Bash

Git Commit with Conventional Commits

Overview

Create standardized, semantic git commits using the Conventional Commits specification. Analyze the actual diff to determine appropriate type, scope, and message.

Conventional Commit Format

<type>[optional scope]: <description>

[optional body]

[optional footer(s)]

Commit Types

TypePurpose
featNew feature
fixBug fix
docsDocumentation only
styleFormatting/style (no logic)
refactorCode refactor (no feature/fix)
perfPerformance improvement
testAdd/update tests
buildBuild system/dependencies
ciCI/config changes
choreMaintenance/misc
revertRevert commit

Breaking Changes

# Exclamation mark after type/scope
feat!: remove deprecated endpoint

# BREAKING CHANGE footer
feat: allow config to extend other configs

BREAKING CHANGE: `extends` key behavior changed

Workflow

1. Analyze Diff

# If files are staged, use staged diff
git diff --staged

# If nothing staged, use working tree diff
git diff

# Also check status
git status --porcelain

2. Stage Files (if needed)

If nothing is staged or you want to group changes differently:

# Stage specific files
git add path/to/file1 path/to/file2

# Stage by pattern
git add *.test.*
git add src/components/*

# Interactive staging
git add -p

Never commit secrets (.env, credentials.json, private keys).

3. Generate Commit Message

Analyze the diff to determine:

  • Type: What kind of change is this?
  • Scope: What area/module is affected?
  • Description: One-line summary of what changed (present tense, imperative mood, <72 chars)

4. Execute Commit

# Single line
git commit -m "<type>[scope]: <description>"

# Multi-line with body/footer
git commit -m "$(cat <<'EOF'
<type>[scope]: <description>

<optional body>

<optional footer>
EOF
)"

Best Practices

  • One logical change per commit
  • Present tense: "add" not "added"
  • Imperative mood: "fix bug" not "fixes bug"
  • Reference issues: Closes #123, Refs #456
  • Keep description under 72 characters

Git Safety Protocol

  • NEVER update git config
  • NEVER run destructive commands (--force, hard reset) without explicit request
  • NEVER skip hooks (--no-verify) unless user asks
  • NEVER force push to main/master
  • If commit fails due to hooks, fix and create NEW commit (don't amend)