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- Git repository initialized locally
- Bash shell access
How to use git-commit
- 1.Run the skill when user requests a commit or mentions "/commit"
- 2.The skill analyzes staged or working tree changes using git diff
- 3.Review the auto-detected commit type and scope from the diff analysis
- 4.Optionally override the type, scope, or description if needed
- 5.The skill stages files intelligently if nothing is currently staged
- 6.Execute the commit with the generated conventional commit message
Use cases
- 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
- 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
The skill can stage files by path, pattern, or use interactive staging (git add -p) to group changes logically before committing.
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.
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.
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.
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
| Type | Purpose |
|---|---|
feat | New feature |
fix | Bug fix |
docs | Documentation only |
style | Formatting/style (no logic) |
refactor | Code refactor (no feature/fix) |
perf | Performance improvement |
test | Add/update tests |
build | Build system/dependencies |
ci | CI/config changes |
chore | Maintenance/misc |
revert | Revert 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)
Related skills
More from github/awesome-copilot and the wider catalog.
excalidraw-diagram-generator
Generate Excalidraw diagrams from natural language descriptions.
documentation-writer
Create structured technical documentation using the Diátaxis framework for tutorials, how-to guides, references, and explanations.
gh-cli
GitHub CLI comprehensive reference for repositories, issues, PRs, Actions, projects, releases, and all GitHub operations from the command line.
prd
Generate comprehensive Product Requirements Documents with executive summaries, user stories, technical specs, and risk analysis.
refactor
Surgical code refactoring to improve maintainability without changing behavior.
java-springboot
Best practices for building high-quality Spring Boot applications with proper architecture and configuration.