commit
Create conventional commit messages without co-author labels. Use when committing code changes or formatting git history.
Best use case
commit is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Create conventional commit messages without co-author labels. Use when committing code changes or formatting git history.
Teams using commit 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/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How commit Compares
| Feature / Agent | commit | 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?
Create conventional commit messages without co-author labels. Use when committing code changes or formatting git history.
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.
SKILL.md Source
# Conventional Commit Create conventional commit messages following the Conventional Commits specification. Never add co-author labels. ## Format ``` <type>(<scope>): <subject> <body> ``` ## Types | Type | Purpose | |---|---| | `feat` | New feature | | `fix` | Bug fix | | `refactor` | Code restructuring (no behavior change) | | `docs` | Documentation only | | `style` | Formatting, whitespace (no code change) | | `test` | Adding or fixing tests | | `chore` | Build, CI, tooling, dependencies | | `perf` | Performance improvement | ## Scope (optional) Use the affected package or module as scope, matching this repo's conventions. Common scopes: - Package names: `console-ui`, `console-server`, `cloud-router`, `ai-engineer`, `sheets-ui` - Subsystems: `billing`, `scheduler`, `auth`, `mcp` - Use the scope from recent commits when in doubt — run `git log --oneline -20` to check ## Rules 1. **No co-author labels** — never add `Co-Authored-By` lines 2. Subject line: imperative mood, lowercase, no period, max 72 chars 3. Body: explain **why**, not what. Wrap at 80 chars 4. One logical change per commit — split unrelated changes 5. Match the project's existing commit style (check recent history) ## Steps 1. Run `git status` and `git diff --cached` to see staged changes 2. If nothing is staged, stage the relevant files (prefer specific files over `git add -A`) 3. Analyze the changes and determine the appropriate type and scope 4. Draft a concise commit message 5. Create the commit using a HEREDOC for proper formatting: ```bash git commit -m "$(cat <<'EOF' type(scope): subject line here Optional body explaining why this change was made. EOF )" ``` 6. Run `git status` after to verify ## Examples ``` feat(console-ui): add group chat with realtime subscriptions fix(console-server): correct next_run calculation for scheduled reports refactor(cloud-router): merge mcp server into main binary chore: update ui-kit to v0.15.0 across packages fix(ai-engineer): handle token limit exceeded in streaming response perf(billing): batch usage dimension writes to reduce DB round-trips ```
Related Skills
pr
Create pull requests with conventional titles using gh CLI. Use when creating PRs, opening pull requests, or pushing branches for review.
codex-review
Run OpenAI Codex code review on current changes or review a plan/design. Use when user asks to review code, review implementation, or run codex review.
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.
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.