
Generating Smart Commits
FreeAutomate your conventional commit message generation.
Free · Opens the source repo
What Generating Smart Commits does
Generating Smart Commits is a tool designed to streamline the process of creating conventional commit messages directly from your staged changes in a Git repository. By analyzing the differences in your code, this skill classifies changes into appropriate categories such as features, fixes, and documentation updates. It adheres to the Conventional Commits specification, ensuring that your commit messages are not only consistent but also informative, which is crucial for maintaining a clean project history.
This skill operates by first requiring the user to stage their changes using git add. Once changes are staged, it can analyze the modifications and determine the type of commit that should be generated. Users can easily trigger the skill with commands like "generate smart commit" or "/commit-smart", which will invoke the analysis and produce a formatted commit message. The tool also identifies breaking changes, allowing developers to communicate significant alterations effectively.
The output follows a structured format, providing a clear and concise description of the changes made, along with an optional body that explains the rationale behind the modifications. This is particularly useful for teams that rely on clear commit histories for collaboration and code reviews. By utilizing this skill, developers can save time and reduce the cognitive load associated with manually crafting commit messages, leading to improved productivity and consistency in their workflow.
Generating Smart Commits is ideal for developers who frequently work with Git and need a reliable way to ensure their commit messages adhere to established conventions. Whether you're working on solo projects or collaborating in larger teams, this tool can enhance your version control practices significantly.
When to use it
Use this skill when you have staged changes in a Git repository and need to generate a conventional commit message quickly and accurately.
When not to use it
This skill is not suitable if you have not staged any changes or if your project does not follow conventional commit standards.
What you can build with it
Generate a commit message after staging changes
After staging your files with `git add`, use this skill to automatically create a conventional commit message that reflects the changes.
Identify breaking changes in your commits
When making significant updates that may affect existing functionality, this skill helps you flag breaking changes in your commit message.
Maintain consistent commit history in a team
Use this skill to ensure all team members adhere to the same commit message conventions, improving clarity and collaboration.
How to install Generating Smart Commits
View source1. Install with the skills CLI
npx skills add jeremylongshore/claude-code-plugins-plus-skills/generating-smart-commits --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by jeremylongshoreGenerating Smart Commits
Current State
!git diff --cached --stat
!git log --oneline -5
!git status --short
Overview
Analyze staged git changes and generate Conventional Commits messages with accurate type classification, scope detection, and breaking change identification. Supports feat, fix, docs, style, refactor, test, chore, perf, ci, and build types following the Conventional Commits 1.0.0 specification.
Prerequisites
- Git repository initialized in the working directory
- Changes staged via
git add(at least one staged file) - Git user name and email configured (
git config user.name,git config user.email) - Understanding of the project's commit message conventions (check recent history)
Instructions
- Run
git diff --cached --statto get an overview of staged files and change volume - Run
git diff --cachedto examine the actual code changes in detail - Classify the commit type based on the nature of changes:
feat: new functionality visible to usersfix: bug correctionrefactor: code restructuring without behavior changedocs: documentation onlytest: adding or updating testschore: build process, dependencies, or toolingperf: performance improvementci: CI/CD configuration changes
- Determine scope from the primary directory or module affected (e.g.,
auth,api,cli,db) - Check for breaking changes: removed public APIs, changed function signatures, renamed exports, schema migrations
- Check recent commit history with
git log --oneline -10to match the project's style conventions - Construct the commit message:
type(scope): imperative description under 72 characters - Add a body with bullet points explaining the "why" behind the change if the diff is non-trivial
- Append
BREAKING CHANGE:footer if applicable
Output
Conventional commit message following this format:
type(scope): imperative description
- Explanation of what changed and why
- Impact on existing functionality
BREAKING CHANGE: description (if applicable)
Error Handling
| Error | Cause | Solution |
|---|---|---|
No changes staged for commit | Nothing added to staging area | Run git add <files> to stage changes before generating the message |
Not a git repository | Working directory is not inside a git repo | Run git init or navigate to the repository root |
Ambiguous commit type | Changes span multiple categories (feature + fix) | Split into separate commits or use the primary intent as the type |
Scope unclear from file paths | Changes touch many unrelated directories | Use the most significant module or omit scope entirely |
Commit message exceeds 72 characters | Description too verbose | Shorten to the essential action; move details to the commit body |
Examples
- "Analyze my staged changes and generate a conventional commit message with the right type and scope."
- "Create a commit message for these changes, checking if there are any breaking changes in the API."
- "Generate a smart commit following this project's existing commit style (check the last 10 commits)."
Resources
- Conventional Commits specification: https://www.conventionalcommits.org/en/v1.0.0/
- Angular commit guidelines: https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit
- Git commit best practices: https://cbea.ms/git-commit/
Frequently asked questions about Generating Smart Commits
Similar skills
Release Candidate Preparation
Streamline your OpenAI Agents release process.
Gitmoji
Generate expressive commit messages with emojis.
GitHub Release
Automate your GitHub library release process effortlessly.
Commit Message Storyteller
Generate meaningful commit messages from your git diffs.
Author Contributions
Trace author contributions across branches in Git.
Implementation Kickoff
Streamline your code implementation process with ease.
