commit
Commit current changes with a clear, descriptive message
Best use case
commit is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Commit current changes with a clear, descriptive message
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?
Commit current changes with a clear, descriptive message
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
# Commit Changes
Commit the current staged/unstaged changes with a well-crafted commit message.
## Arguments
`$ARGUMENTS` can be used for special instructions, such as:
- Guiding the message: "emphasize the breaking change"
- Adding context: "this fixes issue #123"
- Requesting amend: "amend the previous commit"
## Step 1: Gather Information
Run these commands in parallel to understand the changes:
1. **Git status**: `git status --porcelain` (check for staged/unstaged changes)
2. **Staged diff**: `git diff --cached` (what will be committed if there are staged changes)
3. **Unstaged diff**: `git diff` (what's modified but not staged)
4. **Recent commits**: `git log -5 --oneline` (to match existing commit style)
**Important checks:**
- If no changes exist (nothing staged or unstaged), inform the user there's nothing to commit
- If there are unstaged changes but nothing staged, stage all changes with `git add -A` (or ask user if they want to selectively stage)
- If there are both staged and unstaged changes, ask user if they want to include unstaged changes
## Step 2: Analyze Changes
Review the diff to understand:
- **What** changed (files, functions, features)
- **Why** it changed (bug fix, new feature, refactor, etc.)
- **Impact** (breaking changes, dependencies, configuration)
## Step 3: Generate Commit Message
### Message Guidelines
1. **Subject line**:
- Use imperative mood ("add feature" not "added feature")
- Keep under 50 characters (hard limit: 72)
- Don't end with a period
- Use lowercase for the first letter
2. **Body** (if needed for complex changes):
- Separate from subject with blank line
- Wrap at 72 characters
- Explain *what* and *why*, not *how*
- Use bullet points for multiple items
3. **Footer** (if needed):
- Reference issues: `Fixes #123`, `Closes #456`
### Examples
**Simple change:**
```
add user authentication endpoint
```
**Change with body:**
```
add rate limiting to public endpoints
- Implement token bucket algorithm
- Add configurable limits per endpoint
- Include rate limit headers in responses
Closes #234
```
## Step 4: Create the Commit
1. **Stage changes** (if needed):
```bash
git add -A
```
Or stage specific files if user requested selective staging.
2. **Create commit** using HEREDOC for proper formatting:
```bash
git commit -m "$(cat <<'EOF'
<description>
<body if needed>
<footer if needed>
EOF
)"
```
3. **Verify** the commit was created:
```bash
git log -1 --oneline
```
4. **Report** the commit hash and message to the user.
## Edge Cases
- **No changes**: Inform user there's nothing to commit
- **Amend requested**: Use `git commit --amend` (only if explicitly requested in arguments)
- **Large changes**: Suggest breaking into multiple commits if changes span unrelated areas
- **Merge conflicts**: Inform user and provide guidance on resolution
- **Pre-commit hooks fail**: Report the failure and suggest fixesRelated Skills
data-designer
Use when the user wants to create a dataset, generate synthetic data, or build a data generation pipeline.
update-pr
Update an existing GitHub PR description to reflect current changes after incorporating feedback
search-github
Search GitHub issues, discussions, and PRs for content related to a topic
search-docs
Search local documentation in the docs/ folder for content related to a topic
review-code
Perform a thorough code review of the current branch or a GitHub PR by number.
create-pr
Create a GitHub PR with a well-formatted description matching the repository PR template (flat Changes by default; optional Added/Changed/Removed/Fixed grouping)
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.