More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Git Release Composer

    2

    Turns a diff into a changelog entry, with a matching commit message and PR description in the same pass — no git access needed.

    Free

    4 uses5.0 (1 review)
    Git Release Composer

    Git Release Composer

    Example session with this skill installed

    HHere's my diff — write a commit message, PR description, and changelog entry for it:

    diff --git a/src/api/orders.ts b/src/api/orders.ts

    • export function fetchOrder(id) {
    • return db.orders.findById(id);
    • }
    • export function getOrder(orderId, options = {}) {
    • return db.orders.findById(orderId, options);
    • }
    • Read your context and instructions
    • Compiled the git release composer

    Here's all three, generated from the diff:

    Commit message

    ​```
    refactor(orders)!: rename fetchOrder to getOrder, add options param

    fetchOrder is renamed to getOrder for consistency with other
    resource getters, and now accepts an options object for
    future extensibility.

    BREAKING CHANGE: fetchOrder(id) is removed. Replace calls
    with getOrder(orderId, options).
    ​```

    PR description

    ​```markdown

    What changed

    fetchOrder(id) is renamed to getOrder(orderId, options) and now
    takes an options object instead of a single positional argument.

    Why

    Aligns the naming and signature with the other resource getters
    (getUser, getInvoice).

    How to test

    Existing unit tests for fetchOrder were updated to call getOrder;
    run the orders test suite.

    Breaking changes

    fetchOrder is removed. All call sites must switch to
    getOrder(orderId, options).
    ​```

    Changelog entry

    ​```markdown

    Changed

    • fetchOrder(id) is renamed to getOrder(orderId, options) —
      update any direct calls
      ​```

    Next steps: paste the commit message into git commit, the PR
    description into your pull request, and the changelog entry into
    CHANGELOG.md under your next release heading. The breaking-change
    flag was detected automatically from the renamed export and changed
    signature — no need to call it out yourself.

    CHANGELOG.md

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

    About this skill

    Changelog entries always come last and always get written in a rush — different tone, different level of detail, often disconnected from what the commit message or PR description already said about the same change. Git Release Composer fixes that by generating all three from one pass over the diff, so they actually agree with each other.

    Paste a diff, a .patch file, or just describe what changed — the skill classifies the change (feat, fix, refactor, chore, etc.), detects breaking changes, and produces:

    • Changelog entry — Keep a Changelog format, user-facing language, no internal implementation detail
    • Commit message — Conventional Commits format, imperative summary, body explains why, breaking-change footer when applicable
    • PR description — What changed / Why / How to test / Breaking changes, with empty sections omitted rather than padded with "N/A"

    This is a pure text-generation skill: no git commands are run and no repository access is required. That makes it a fit for read-only agents, restricted environments, or anyone who just wants the words handed to them without any automation attached — a lighter-weight complement to full git-execution/code-review skills, not a replacement for one.

    Compatible with Claude Code, Cursor, Codex CLI, Gemini CLI, VS Code Copilot, and any other SKILL.md-compatible agent.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Technical Documentation.

    • Works from the diff/text you provide — it doesn't read your repository, so it can't see cross-file context, runtime behavior, or history beyond what's in the pasted change.
    • Breaking-change detection is pattern-based (removed/renamed exports, changed signatures, dropped config keys or columns) — it can miss subtler breaking changes that don't show up as a structural diff, like a behavior change with no signature change.
    • Doesn't check your repo for an existing PR template or CONTRIBUTING conventions — output follows this skill's own default templates, which may not match a template your project already uses.
    • Won't infer intent it can't see: no issue/ticket number unless you provide one, no "security fix" label unless the diff or your description actually says so.
    • If a diff bundles several unrelated changes, it flags that and suggests splitting, but doesn't split the diff for you — you'd still generate outputs per change yourself.
    • Doesn't run any git commands, tests, or linters — it's text generation only, not verification that the change works.

    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 buying a skill.

    Reviews

    5.0
    1 review
    5
    1
    4
    0
    3
    0
    2
    0
    1
    0

    This skill has been used 4 times.

    Trust & safety

    Security scan

    Security scan passed 2 months ago

    • Free with an Agensi account

    Software
    Git

    Permissions

    Terminal / Shell
    Listed2 months ago

    What's inside

    Frequently Asked Questions

    It generates a synchronized changelog entry, a conventional commit message, and a pull request description simultaneously from a single diff, ensuring all three documents are consistent in tone and detail.

    This is a text-based skill that requires no repository access or git permissions; you simply provide a diff or patch, and it returns the formatted text for you to use manually or via your agent.

    Yes, the skill is designed to work with any agent that supports the SKILL.md format, including Claude Code, Cursor, VS Code Copilot, and various CLI-based AI tools.

    The skill automatically classifies changes into standard categories like feat, fix, or refactor, and it explicitly flags breaking changes in the commit footer and PR notes.

    Upon purchase, you receive the skill definition files including the optimized prompts and formatting logic, which you can immediately import into your preferred AI agent environment.

    While it is optimized for .diff and .patch files, you can also provide a raw text description of your changes, and the skill will still generate the formatted documentation accordingly.

    New in Technical Documentation

    Free