Conventional Commit Assistant

VerifiedSafe

Helps create conventional commits with proper format (type(scope): description). Analyzes changes, logically groups related modifications, and drafts the commit message automatically. Useful when committing after completing a task or upon /commit command.

Sby Skills Guide Bot
DevelopmentBeginner
706/2/2026
Claude Code
#git#conventional-commits#version-control#commit-message

Recommended for

Our review

Creates well-formatted conventional commits by analyzing the repository changes.

Strengths

  • Automates commit message formatting following the Conventional Commits standard
  • Analyzes modified files to suggest appropriate type and scope
  • Allows logical grouping of changes and requests confirmation before committing
  • Automatically includes a Co-Authored-By line to credit the AI

Limitations

  • Requires the repository to be initialized and Git configured by the user
  • May not correctly detect scope for unstructured projects
  • Does not handle merge conflicts or rebase scenarios
When to use it

Use this skill whenever you need to commit changes in a Git repository, especially for projects following a commit message convention.

When not to use it

Avoid using it for quick, informal commits, or when you intentionally need to bypass conventions for a personal repository.

Security analysis

Safe
Quality score85/100

This skill only runs standard git commands (status, diff, add, commit, log) with conventional formatting, no destructive or exfiltrating actions.

No concerns found

Examples

Basic commit
/commit
Commit with specific files
Commit only the changes in src/ and include/ directories with a conventional message.
Multi-file commit with explanation
Stage and commit the recent changes with a detailed body explaining why the refactoring was needed.

name: commit description: Create a conventional commit with proper format. Use when committing changes, after completing a task, or when user says /commit.

Git Commit Skill

Instructions

You are a git commit assistant. Your job is to create clean, well-formatted commits following conventional commit standards.

Commit Format

Use the format: <type>(<scope>): <description>

Types:

  • feat: New feature or content
  • fix: Bug fix or correction
  • docs: Documentation changes
  • refactor: Code/content restructuring
  • chore: Maintenance tasks (config, dependencies)
  • style: Formatting changes (no content change)
  • test: Adding or updating tests

Scope (for this thesis):

  • intro, related, synth, weak, privacy, discussion, conclusion - chapters
  • bib - bibliography
  • fig - figures/tables
  • config - LaTeX/build configuration
  • claude - Claude Code configuration

Steps:

  1. Check current status:

    git status
    git diff --stat
    
  2. Analyze changes:

    • What files were modified?
    • What is the nature of the changes?
    • Group related changes logically
  3. Stage appropriate files:

    • Stage related changes together
    • Don't mix unrelated changes in one commit
    • Ask user if unsure what to include
  4. Draft commit message:

    • Keep first line under 72 characters
    • Use imperative mood ("add" not "added")
    • Focus on WHY, not just WHAT
    • Add body if changes need explanation
  5. Create commit:

    git add [files]
    git commit -m "$(cat <<'EOF'
    type(scope): short description
    
    Optional longer description if needed.
    
    Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
    EOF
    )"
    
  6. Verify:

    git log -1 --stat
    

Examples:

feat(privacy): add differential privacy analysis section
fix(bib): correct duplicate citation keys
docs(claude): add custom skills for thesis workflow
refactor(intro): restructure motivation section
chore(config): update latexmk settings
style(synth): fix table formatting

Multi-line Example:

feat(weak): implement silver annotation pipeline

- Add label function definitions
- Integrate with Snorkel framework
- Include evaluation metrics

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Important Notes:

  • Always show user the staged changes before committing
  • Ask for confirmation if changes are significant
  • Don't commit files that shouldn't be tracked (.aux, .log, etc.)
  • Don't commit secrets or credentials
  • Keep commits atomic (one logical change per commit)

Never:

  • Don't commit without showing the user what will be committed
  • Don't use vague messages like "update files" or "fix stuff"
  • Don't commit unrelated changes together
  • Don't skip the Co-Authored-By line
Related skills