Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    commit message writer

    1

    Generate precise, convention-compliant git commit messages based on staged diff evidence.

    Free

    Security scanned
    commit message writer

    commit message writer

    Example session with this skill installed

    I have staged changes in the api/auth folder. Write a commit message following this repo's Conventional Commits style.

    • Read your context and instructions
    • Compiled the commit message writer

    I have analyzed the staged changes in `api/auth/session.ts` and `api/auth/token.ts`. The diff shows a fix for a race condition during token refresh and the addition of an expiration check. ## Recommended Commit Message ```text fix(api): reject expired invite tokens during refresh Validate token expiration timestamps before generating new session secrets. Previously, the system allowed refresh requests for tokens that had already reached their TTL, leading to zombie sessions. - Added expiration check to `validateToken` function - Updated session middleware to handle 401 Unauthorized for expired tokens ``` **Diff scope used:** - `api/auth/session.ts` - `api/auth/token.ts` **Convention basis:** Conventional Commits (type: fix, scope: api) **Next steps** 1. Review the proposed message for accuracy. 2. Run `git commit -m "[message]"` or ask me to execute the commit for you. 3. Check if any other unstaged changes in `api/` need to be included.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Commit messages are often the last thing developers want to spend brainpower on, leading to generic "updates" or "fix" descriptions that provide zero value to future maintainers. This skill bridges the gap between raw diffs and high-quality documentation by generating precise commit messages based on staged changes. It eliminates the guesswork and manual typing required to follow strict conventions like Conventional Commits. ## What it does - **Diff analysis** examines staged changes to determine the exact intent and behavior modifications. - **Convention matching** identifies the repository style from recent history to ensure consistency. - **Contextual rationale** drafts commit bodies that explain the "why" behind changes rather than just listing files. - **Standard compliance** applies Conventional Commit types like feat, fix, or refactor with proper scoping. - **Safety checks** flags potential breaking changes and filters out personal or sensitive data. - **Commit splitting** suggests breaking up changes if too many files or directories are modified at once. ## How it works 1. **Inspect staged files** by running `git diff --cached` to see exactly what is being committed. 2. **Identify style** by reviewing repository contribution docs and recent commit subjects. 3. **Draft message** including a concise subject line, optional body for rationale, and footer references. 4. **Final review** to ensure no unstaged work is included and that all claims trace back to the diff evidence. ## Frameworks & tools This skill works directly with `git` and supports repository-specific conventions including Conventional Commits. ## Why this beats prompting it yourself Generic prompts often hallucinate issue numbers or fail to distinguish between staged and unstaged changes. This skill strictly follows an evidence-readiness gate, ensuring every word in the message is backed by the actual code diff and existing repository style. ## Use cases - Generating standardized Conventional Commits for enterprise monorepos. - Summarizing complex refactors into readable developer rationale. - Ensuring breaking changes are properly flagged in the commit footer. - Cleaning up commit history before a pull request review. ## Known limitations Does not support inferring scope from branch names alone. Requires an explicit staged diff or commit range to function.

    Requires a staged diff or commit range. Will not infer scope from branch names. Suggests splitting commits if more than 5 files across 2 directories are changed.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    • Free with an Agensi account

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed2 days ago

    What's inside

    Frequently Asked Questions

    The skill analyzes your staged git diffs and repository history to generate messages that follow standards like Conventional Commits (feat, fix, refactor), ensuring your project history remains professional and searchable without manual effort.

    No, this skill strictly analyzes your staged changes (`git diff --cached`) to ensure the message accurately reflects only the code you are about to commit, preventing common AI hallucinations regarding unstaged files.

    The skill identifies breaking changes within your code and automatically formats the commit footer with the 'BREAKING CHANGE' flag, helping your team maintain accurate semantic versioning.

    Upon purchase, you receive the production-ready agent skill, a configuration guide for various CLI environments, and documentation on how to integrate it into your existing CI/CD or local development workflow.

    This skill is designed to work with any AI agent platform that supports git-based tool calling and code analysis; it requires a standard git installation and access to your local repository's diff evidence.

    If a diff is too large or covers disparate modules, the skill will suggest logical commit splits, helping you maintain a clean, atomic commit history that is easier for peers to review.

    New in Code Quality & Review