Skip to content
Skills Library
Programming · Automation

conventional-commit-gen

/conventional-commit-gen

Analyzes git diff to generate commit messages following the Conventional Commits spec, with automatic scope detection and commit type inference. Trigger when users ask to write or generate a commit message, mention Conventional Commits, git commits, standardized commits, scope detection, or phrases like 'help me write a commit message'.

Repository
kimi-skills ↗
Licence
MIT
Last repository change
17.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
1
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 17.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/analyze_diff.py

What it does and when to use it

Analyzes git diff to generate commit messages following the Conventional Commits spec, with automatic scope detection and commit type inference. Trigger when users ask to write or generate a commit message, mention Conventional Commits, git commits, standardized commits, scope detection, or phrases like 'help me write a commit message'.

Triggers from the description

help me write a commit message
Original author description

Analyzes git diff to generate commit messages following the Conventional Commits spec, with automatic scope detection and commit type inference. Trigger when users ask to write or generate a commit message, mention Conventional Commits, git commits, standardized commits, scope detection, or phrases like 'help me write a commit message'.

How it works

  1. Quick Start
  2. Usage Workflow (SOP)
  3. Parameters
  4. Prerequisites
Original SKILL.md headings · 96 lines, 482 words
SKILL.md preview
---
name: conventional-commit-gen
description: "Analyzes git diff to generate commit messages following the Conventional Commits spec, with automatic scope detection and commit type inference. Trigger when users ask to write or generate a commit message, mention Conventional Commits, git commits, standardized commits, scope detection, or phrases like 'help me write a commit message'."
type: tool
license: MIT
tags:
  - git
  - conventional-commits
  - devops
  - productivity
---

# Conventional Commit Gen

Analyzes the current git diff and automatically generates a commit message that follows the [Conventional Commits](https://www.conventionalcommits.org/) specification, with smart scope detection.

## Quick Start

```bash
# Analyze unstaged changes and generate a commit message
python3 scripts/analyze_diff.py

# Analyze staged changes only
python3 scripts/analyze_diff.py --staged

# Specify a repository path
python3 scripts/analyze_diff.py --repo /path/to/repo

# JSON output (useful for programmatic integration)
python3 scripts/analyze_diff.py --staged --format json

# Manually override type or scope
python3 scripts/analyze_diff.py --staged --type-override feat --scope-override auth
```

## Usage Workflow (SOP)

### 1. Get the Diff Analysis

Run the script in the user's git repository to get the automated analysis:

```bash
python3 scripts/analyze_diff.py --staged --format json
```

### 2. Review and Adjust

The script outputs:
- **type**: The auto-detected commit type (feat / fix / docs / style / refactor / test / chore / perf / ci / build)
- **scope**: The scope detected from file paths (e.g., auth, api, ui)
- **description**: A brief description generated from the change summary
- **commit_message**: The fully assembled commit message

After reviewing the output, adjust as needed:
- If the type is inaccurate (e.g., the script detected `chore` but it's actually a `feat`), use `--type-override` to override
- If the scope doesn't fit, use `--scope-override` to override
- The description should ideally be hand-written based on the actual changes; treat the script output as a starting point

> **Note**: Type detection is based on file paths and change statistics. It works well for types like test/docs/ci/build, but for modifications to existing source code files (feat vs fix vs refactor), you should read the diff content and make the final call.

### 3. Conventional Commits Reference

```
<type>(<scope>): <description>

[optional body]

[optional footer(s)]
```

| Type       | Meaning                                    |
|------------|--------------------------------------------|
| `feat`     | A new feature                              |
| `fix`      | A bug fix                                  |
| `docs`     | Documentation changes                      |
| `style`    | Code formatting (no logic changes)         |
| `refactor` | Refactoring (no new features or bug fixes) |
| `test`     | Test-related changes                       |
| `chore`    | Build/tooling/dependency maintenance       |
| `perf`     | Performance improvements                   |
| `ci`       | CI/CD configuration changes                |
| `build`    | Build system or external dependency changes|

### 4. Breaking Changes

If the change includes a breaking change, add `!` after the type:

```
feat(api)!: change authentication endpoint response format
```

## Parameters

| Parameter           | Description                                       | Default  |
|---------------------|---------------------------------------------------|----------|
| `--repo`            | Path to the git repository                        | `.`      |
| `--staged`          | Analyze staged changes only                       | No       |
| `--format`          | Output format: `text` or `json`                   | `text`   |
| `--type-override`   | Manually specify the commit type, skipping auto-detection | None |
| `--scope-override`  | Manually specify the scope, skipping auto-detection | None   |

## Prerequisites

- Python 3.6+
- git installed and available in PATH
- Current directory or `--repo` points to a valid git repository
Files in this package (3)
  • LICENSE 1 KB
  • SKILL.md 4 KB
  • scripts/analyze_diff.py 11 KB

Versions

The database has no other skills named conventional-commit-gen.

Database snapshot: 13.11.2026 · package version e56441ba68d0 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100commit-message
    Generate conventional commit messages - use when creating commits, writing commit messages, or asking for git commit help
  • 100generating-conventional-commits
    Execute generates conventional commit messages using AI. It analyzes code changes and suggests a commit message adhering to the conventional commits specification. Use this skill when you need help writing clear, standardized commit messages, especially a... Use when managing…
  • 100commit-helper
    Helps write Git commit messages following the Conventional Commits specification. Use this skill when the user asks to commit changes, write commit messages, format commits, or mentions git commits.
  • 84generate-commit-message
    Generate well-structured git commit messages. Use when user says "generate commit message", "write a commit", "what should my commit message be", "create commit message for these changes", or needs help crafting conventional commit messages.
  • 100smart-commit-gen
    Conventional Commits 规范化工具:分析 git diff 自动生成符合规范的提交信息,支持自动检测作用域(scope)并智能推断提交类型(如 feat, fix, refactor)。当用户提及 commit message、提交信息、conventional commits、git commit、规范化提交、scope 检测,或提出“帮我写个 commit message”、“这些改动应该怎么提交”、“分析一下 diff 生成提交信息”等请求时触发。
  • 90Conventional Commits
    This skill should be used when the user asks to 'write commit message', 'create conventional commit', 'format git commit', 'follow commit conventions', 'structure commit message'. Provides Conventional Commits patterns for consistent, machine-readable commit messages.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.