generating-smart-commits
This skill generates conventional commit messages using AI analysis of staged Git changes. It automatically determines the commit type (feat, fix, docs, etc.), identifies breaking changes, and formats the message according to conventional commit standards. Use this when asked to create a commit message, write a Git commit, or when the user uses the `/commit-smart` or `/gc` command. It is especially useful after changes have been staged with `git add`.
91
53%
Does it follow best practices?
Impact
98%
1.04xAverage score across 9 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./backups/skills-migration-20251108-070147/plugins/devops/git-commit-smart/skills/git-commit-smart/SKILL.mdQuality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is an excellent skill description that clearly communicates what the skill does (generates conventional commit messages with AI analysis), when to use it (explicit trigger clause with commands and natural language scenarios), and provides enough specificity to distinguish it from other skills. It uses proper third-person voice throughout and includes both natural language triggers and specific command triggers.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: generates conventional commit messages, determines commit type (feat, fix, docs, etc.), identifies breaking changes, and formats according to conventional commit standards. | 3 / 3 |
Completeness | Clearly answers both 'what' (generates conventional commit messages using AI analysis of staged Git changes, determines commit type, identifies breaking changes) and 'when' (explicit 'Use this when...' clause with multiple trigger scenarios including commands and natural language requests). | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms users would say: 'commit message', 'Git commit', '/commit-smart', '/gc', 'git add', 'staged changes'. Good coverage of both natural language and command-based triggers. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a clear niche: conventional commit message generation from staged Git changes. The specific commands (/commit-smart, /gc), the conventional commit format focus, and the Git-specific context make it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
7%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill content reads like a marketing description rather than actionable instructions for Claude. It lacks any concrete implementation details—no git commands, no commit type definitions, no message format specification, no code for analyzing diffs. Nearly every section explains concepts Claude already understands or describes behavior abstractly rather than providing executable guidance.
Suggestions
Replace the abstract 'How It Works' section with concrete steps: run `git diff --cached`, analyze the output, determine commit type from a defined list (feat, fix, docs, style, refactor, test, chore, etc.), and format the message.
Add the actual conventional commit format specification: `<type>(<scope>): <description>\n\n<body>\n\n<footer>` with rules for breaking changes (BREAKING CHANGE footer or `!` after type).
Include executable code or commands, e.g., `git diff --cached --stat` for overview and `git diff --cached` for detailed changes, and show how to construct and execute the commit with `git commit -m "..."` after user confirmation.
Remove the 'Overview', 'When to Use This Skill', 'Best Practices', and 'Integration' sections entirely—they explain things Claude already knows and consume tokens without adding actionable value.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is verbose and explains things Claude already knows (what conventional commits are, what staged changes are, how Git works). Sections like 'How It Works', 'When to Use This Skill', and 'Integration' add no actionable value. The overview paragraph is pure filler. | 1 / 3 |
Actionability | There is no executable code, no actual git commands, no concrete implementation of how to analyze staged changes (e.g., `git diff --cached`), no commit message format specification, and no list of valid commit types. The examples describe what the skill 'will do' rather than instructing Claude how to do it. | 1 / 3 |
Workflow Clarity | The workflow steps are vague descriptions ('analyze staged changes', 'generate commit message') with no concrete commands, no validation steps, and no error handling. There's no guidance on what to do if no changes are staged, if the diff is too large, or how to handle breaking changes. | 1 / 3 |
Progressive Disclosure | The content has clear section headers and some organizational structure, but it's a monolithic file with no references to external resources. The content that exists is mostly filler rather than being appropriately split between overview and detail. | 2 / 3 |
Total | 5 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Commit
9fad7ed
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.