generating-smart-commits
Execute use when generating conventional commit messages from staged git changes. Trigger with phrases like "create commit message", "generate smart commit", "/commit-smart", or "/gc". Automatically analyzes changes to determine commit type (feat, fix, docs), identifies breaking changes, and formats according to conventional commit standards.
83
81%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
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 a strong skill description that clearly communicates its purpose, provides explicit trigger terms and commands, and lists specific capabilities. The description is concise yet comprehensive, covering the what and when effectively. The only minor issue is the slightly awkward opening 'Execute use when' which reads like a fragment, but it doesn't materially impact skill selection.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: analyzes changes, determines commit type (feat, fix, docs), identifies breaking changes, and formats according to conventional commit standards. | 3 / 3 |
Completeness | Clearly answers both what (analyzes staged changes, determines commit type, identifies breaking changes, formats per conventional commit standards) and when (explicit trigger phrases and use-case scenario provided). | 3 / 3 |
Trigger Term Quality | Includes natural trigger phrases users would say: 'create commit message', 'generate smart commit', '/commit-smart', '/gc', plus domain terms like 'conventional commit', 'staged git changes', and commit types. | 3 / 3 |
Distinctiveness Conflict Risk | Highly specific niche: conventional commit message generation from staged git changes. The specific slash commands ('/commit-smart', '/gc') and domain-specific terms make it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
62%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a solid workflow for generating conventional commit messages with good step sequencing and error handling. Its main weaknesses are moderate verbosity (prerequisites, resources, and example prompts that don't add instructional value) and a lack of concrete input-to-output examples showing a real diff mapped to a real commit message. The type classification guidance is useful but could be more concise.
Suggestions
Add a concrete worked example showing a real (small) git diff and the resulting commit message, rather than just listing user prompt examples.
Remove or significantly trim the Prerequisites section (Claude knows what git repos and staging are), the Resources section (external URLs Claude can't browse), and the Examples section (user prompts don't teach Claude how to perform the task).
Replace the abstract 'Construct the commit message' step with a more concrete mapping from diff characteristics to output, showing how classification decisions translate into the final message.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary content like the Prerequisites section (Claude knows what a git repo is and how staging works), the Resources section with external links Claude can't browse, and the Examples section which just shows user prompts rather than adding instructional value. The Overview also restates what the instructions already cover. However, it's not egregiously verbose. | 2 / 3 |
Actionability | The instructions provide a clear step-by-step process with specific git commands, but the actual commit message generation is described abstractly ('Construct the commit message') rather than showing executable logic. The output format example is helpful but there's no concrete example showing a real diff mapped to a real commit message, which would make this much more actionable. | 2 / 3 |
Workflow Clarity | The workflow is clearly sequenced from analyzing staged changes through classification, scope detection, breaking change identification, style matching, and message construction. The error handling table provides good recovery guidance for common failure modes. The steps are logically ordered and each builds on the previous one. | 3 / 3 |
Progressive Disclosure | The content is reasonably well-structured with clear sections, but it's somewhat monolithic for its length. The Current State section with shell commands at the top is a nice touch. However, there are no bundle files and no references to supplementary materials that could offload the error handling table or detailed type classification rules. For a skill of this complexity, the single-file approach is borderline acceptable. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
allowed_tools_field | 'allowed-tools' contains unusual tool name(s) | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Commit
3a2d27d
- 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.