Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Commit and PR Writer

    1

    Enforce atomic commits and reviewer-first PRs using git diff analysis and automated linting.

    Free

    2 usesSecurity scanned
    Commit and PR Writer

    Commit and PR Writer

    Example session with this skill installed

    Analyze my staged changes in the current repo, suggest how to split them if they touch different areas, and draft a commit message for the main logic.

    • Read your context and instructions
    • Compiled the commit and pr

    I have analyzed the staged changes. You have modifications in src/auth/, tests/auth/, and a stray change in docs/api.md. I recommend splitting these into two commits to maintain atomic history.

    Staged Changes Analysis

    AreaFilesInsertionsDeletions
    src/auth/24512
    tests/auth/1200
    docs/api.md152

    Suggested Split

    1. Auth Logic: git add src/auth/ tests/auth/
    2. Documentation: git add docs/api.md

    Drafted Commit Message (Auth Logic)

    add jwt token revocation to auth provider
    
    Why: The current implementation allows tokens to remain valid until 
    expiry even after user logout, creating a security gap for leaked tokens.
    
    Affects: src/auth/provider.py, src/auth/store.py, tests/auth/test_revocation.py.
    Deliberately avoids touching the session cookie logic.
    
    Verified: python3 -m pytest tests/auth/test_revocation.py -> 3 passed, 0 failed
    Watch: Increased latency on logout due to the new Redis write for the blacklist.
    

    Next steps

    1. Run git reset to unstage the current pile.
    2. Execute the "Auth Logic" git add suggested above.
    3. Commit using the drafted message, ensuring the Verified command matches your local run.

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

    About this skill

    Reviewers often read the commit message and PR body before the diff, yet these are typically written in a hurry from memory. This leads to vague descriptions like "fix stuff" and unrelated changes being crammed into single commits, making code reviews difficult and rollbacks impossible. This skill enforces a disciplined git workflow that prioritizes the reviewer's needs and ensures every change is documented with technical precision.

    What it does

    • Diff analysis extracts file counts, insertions, deletions, and structural changes directly from git before writing begins.
    • Concern splitting analyzes staged paths by area to suggest separate commits for unrelated changes, ensuring clean history.
    • Message drafting generates imperative subjects under 72 characters and structured bodies covering the "why," impact, and verification.
    • Automated linting validates messages for length, mood, vagueness, and mandatory verification commands to prevent low-quality logs.
    • PR assembly builds reviewer-first pull request bodies including risk assessments, rollback plans, and grouped commit summaries.

    How it works

    1. Analyze: Run facts to get a data-driven report of what actually changed in the staged files or commit range.
    2. Organize: Use split to group changes by logical area and generate the specific git add commands needed for atomic commits.
    3. Draft: Execute draft to produce a subject line and body scaffold based on the largest functional changes detected.
    4. Validate: Pipe the written message through lint to check for vagueness, missing verification commands, or subject line errors.

    Frameworks & tools

    The core logic is contained in a Python script using the standard library. It interacts directly with git CLI via subcommands like facts, split, draft, pr, and lint. It requires no external dependencies or network access.

    Why this beats prompting it yourself

    Generic AI prompts often guess what changed based on filenames alone and produce "hallucinated" summaries of the logic. This skill uses a Python-backed analysis of the actual git diff to ground every claim in data, ensuring the "Verified" and "Risk" sections reflect real code impact rather than polite filler.

    Use cases

    • Splitting a large, messy "work in progress" stash into a clean series of atomic commits.
    • Generating a professional PR description for a complex branch with multiple contributors.
    • Enforcing commit message standards across a team to ensure "fix stuff" never hits the main branch.
    • Validating that every commit includes a repeatable verification command and output log.

    Known limitations

    It requires a local git environment and Python 3. The lint command needs access to the repository to validate diff-related claims; without it, only basic subject and body formatting checks are performed.

    Requires Python 3 and local git access. Automated diff checks are skipped if the repository is not accessible during linting. Cannot automatically run tests or fix code.

    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

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Python
    Git

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill solves the 'fix stuff' problem by analyzing your actual git diffs to generate atomic commits and structured PRs, making code reviews faster and rollbacks easier. It acts as a bridge between your code changes and your documentation, ensuring every commit message is data-driven and technically precise.

    No, this skill is designed for maximum security and privacy; it runs entirely on your local machine using a Python-based analysis engine. It does not require an internet connection or send your proprietary source code to external servers to generate descriptions.

    The skill requires a local Git environment and Python 3. It is designed to be compatible with any AI agent that supports local script execution and terminal interaction.

    You receive the core Python-backed git utility, a suite of specialized commands (facts, split, draft, lint, pr), and clear documentation on integrating it with your AI agent's environment.

    While it can draft messages for any size change, its 'split' command is specifically designed to identify unrelated changes in large stashes and suggest how to break them into smaller, atomic commits.

    The 'lint' feature acts as an automated quality gate, scanning drafts for imperative mood, vagueness, and mandatory verification sections before you ever push to a remote repository.

    New in Code Quality & Review