commit-messages
Generate clear, conventional commit messages from git diffs. Use when writing commit messages, reviewing staged changes, or preparing releases.
Best use case
commit-messages is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Generate clear, conventional commit messages from git diffs. Use when writing commit messages, reviewing staged changes, or preparing releases.
Teams using commit-messages should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/commit-messages/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How commit-messages Compares
| Feature / Agent | commit-messages | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Generate clear, conventional commit messages from git diffs. Use when writing commit messages, reviewing staged changes, or preparing releases.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
SKILL.md Source
# Commit Message Skill Generate consistent, informative commit messages following the Conventional Commits specification. ## When to Use This Skill - User asks to "commit", "write a commit message", or "prepare commit" - User has staged changes and mentions commits - Before any `git commit` command ## Process 1. **Analyze changes**: Run `git diff --staged` to see what's being committed 2. **Identify the type**: Determine the primary change category 3. **Find the scope**: Identify the main area affected 4. **Write the message**: Follow the format below ## Commit Message Format ``` <type>(<scope>): <description> [optional body] [optional footer(s)] ``` ### Types | Type | Description | Example | |------|-------------|---------| | `feat` | New feature | `feat(auth): add OAuth2 login` | | `fix` | Bug fix | `fix(api): handle null response` | | `docs` | Documentation only | `docs(readme): add setup instructions` | | `style` | Formatting, no code change | `style: fix indentation` | | `refactor` | Code change, no new feature/fix | `refactor(db): extract query builder` | | `perf` | Performance improvement | `perf(search): add result caching` | | `test` | Adding/fixing tests | `test(auth): add login unit tests` | | `build` | Build system changes | `build: update webpack config` | | `ci` | CI configuration | `ci: add GitHub Actions workflow` | | `chore` | Maintenance tasks | `chore(deps): update dependencies` | | `revert` | Revert previous commit | `revert: feat(auth): add OAuth2` | ### Scope The scope should be a noun describing the section of the codebase: - `auth`, `api`, `db`, `ui`, `config` - Feature names: `search`, `checkout`, `dashboard` - Or omit if change is broad ### Subject Line Rules - Use imperative mood: "add" not "added" or "adds" - Don't capitalize first letter after colon - No period at the end - Max 72 characters total ### Body (when needed) - Separate from subject with blank line - Explain *what* and *why*, not *how* - Wrap at 72 characters - Use bullet points for multiple changes ### Footer (when needed) - `BREAKING CHANGE:` for breaking changes - `Fixes #123` to close issues - `Refs #456` to reference without closing ## Examples ### Simple feature ``` feat(search): add fuzzy matching support Implement Levenshtein distance algorithm for typo tolerance in search queries. Configurable via FUZZY_THRESHOLD env var. ``` ### Bug fix with issue reference ``` fix(cart): prevent duplicate items on rapid clicks Add debounce to add-to-cart button and check for existing items before insertion. Fixes #234 ``` ### Breaking change ``` feat(api)!: change response format to JSON:API BREAKING CHANGE: API responses now follow JSON:API spec. All clients need to update their parsers. - Wrap data in `data` object - Move metadata to `meta` object - Add `links` for pagination ``` ### Multiple related changes ``` refactor(auth): consolidate authentication logic - Extract JWT handling to dedicated service - Move session management from controller to middleware - Add refresh token rotation This prepares for the upcoming OAuth2 integration. ``` ## Output When generating a commit message: 1. Show the staged changes summary 2. Propose the commit message 3. Explain the type/scope choice if non-obvious 4. Ask if the user wants to proceed or modify
Related Skills
security-audit
Audit code and dependencies for security vulnerabilities. Use when reviewing PRs, checking dependencies, preparing for deployment, or when user mentions security, vulnerabilities, or audit.
commit
ALWAYS use this skill when committing code changes — never commit directly without it. Creates commits following Sentry conventions with proper conventional commit format and issue references. Trigger on any commit, git commit, save changes, or commit message task.
git-commit-helper
Generate standardized git commit messages following Conventional Commits format. Use this skill when the user asks to commit code, write a commit message, or create a git commit. Enforces team conventions for type prefixes, scope naming, message length, and breaking change documentation.
messages-ops
Evidence-first live messaging workflow for ECC. Use when the user wants to read texts or DMs, recover a recent one-time code, inspect a thread before replying, or prove which message source was actually checked.
git-commit
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
conventional-commit
Prompt and workflow for generating conventional commit messages using a structured XML format. Guides users to create standardized, descriptive commit messages in line with the Conventional Commits specification, including instructions, examples, and validation.
commit
Create commit messages following Sentry conventions. Use when committing code changes, writing commit messages, or formatting git history. Follows conventional commits with Sentry-specific issue references.
commit-work
Create high-quality git commits: review/stage intended changes, split into logical commits, and write clear commit messages (including Conventional Commits). Use when the user asks to commit, craft a commit message, stage changes, or split work into multiple commits.
commit-smart
Analyze staged/unstaged changes and create semantic conventional commits with context about WHY, not just WHAT. Auto-detects commit type and scope from the diff. Supports optional type/scope arguments. Usage - /commit-smart, /commit-smart fix, /commit-smart refactor api
Git Commit Helper
Generate descriptive commit messages by analyzing git diffs. Use when the user asks for help writing commit messages or reviewing staged changes.
contextual-commit
Write contextual commits that capture intent, decisions, and constraints alongside code changes. Use when committing code, finishing a task, or when the user asks to commit. Extends Conventional Commits with structured action lines in the commit body that preserve WHY code was written, not just WHAT changed.
git-commit
Create a git commit with a clear, value-communicating message. Use when the user says "commit", "commit this", "save my changes", "create a commit", or wants to commit staged or unstaged work. Produces well-structured commit messages that follow repo conventions when they exist, and defaults to conventional commit format otherwise.