Automated Changelog Generation from Git History with AI

The Changelog Problem

Writing changelogs manually is tedious and often skipped. AI analyzes your git history — commit messages, PR descriptions, and diffs — to generate structured, user-friendly changelogs automatically.

The raw material is already sitting in your repository. Every merged pull request, every squashed commit, and every tagged release carries the story of what changed. The hard part has never been finding the data — it is the translation. A commit that reads fix: null guard in tokenizer means nothing to the marketing team drafting a launch email, and a wall of forty commit subjects means nothing to a customer scanning for the one feature they have been waiting on. An AI changelog generator sits between the git graph and the reader, turning shorthand engineering intent into prose the intended audience can actually use.

How It Works

import vincony

client = vincony.Client(api_key="YOUR_API_KEY")

changelog = client.tools.generate_changelog(
    repo="./",
    from_ref="v1.2.0",
    to_ref="HEAD",
    format="keep-a-changelog",
    categories=["added", "changed", "fixed",
                "deprecated", "removed", "security"],
    audience="end_users",
    include_breaking_changes=True
)

print(changelog.markdown)
changelog.save("CHANGELOG.md")
print(f"Changes: {changelog.total_changes}")
print(f"Breaking: {len(changelog.breaking_changes)}")

Grouping by Change Type

The AI doesn't just list commits — it groups related changes, deduplicates, and writes human-readable descriptions. Internal refactors are separated from user-facing features. The standard taxonomy borrows from the Keep a Changelog convention: Added, Changed, Deprecated, Removed, Fixed, and Security. Breaking changes get their own prominent callout so upgraders are never surprised at runtime.

If your team follows conventional commits — prefixes like feat:, fix:, chore:, and BREAKING CHANGE: footers — the classifier has an easy job and can map prefixes straight to sections. But it does not depend on discipline. When commit messages are inconsistent (as they always are on a real team), the model reads the diff and the PR title to infer the category, so a stray update stuff commit still lands in the right bucket instead of a "Miscellaneous" dumping ground. This is where AI beats a pure regex-based generator: it degrades gracefully on messy history.

Writing for the Audience

The single most important knob is who is reading. A changelog aimed at end users should hide the plumbing: nobody outside the team cares that you migrated a serialization helper. A developer-facing changelog for an SDK or public API is the opposite — those internal details are the whole point, because they signal migration work. The generator lets you set audience="end_users" or audience="developers" and rewrites the same commits at the appropriate altitude. You can produce both from one run: a polished user summary for the release page and a technical appendix for the docs site.

Because DevAICodeCenter routes AI infrastructure through Vincony's unified aggregator, you get one API key across 800+ models and can pick a cheaper, faster model for routine patch releases and a stronger model for major-version narratives — without rewriting any code. The Smart Model Router can make that choice for you per request, balancing cost against the length and importance of the diff.

Release Notes Generation

Beyond changelogs, generate polished release notes for GitHub releases, blog announcements, and email notifications — all from the same git data.

# Generate release notes
notes = client.tools.release_notes(
    changelog=changelog,
    formats=["github_release", "blog_post", "email"],
    tone="professional",
    highlight_top=3
)

for fmt in notes.formats:
    print(f"--- {fmt.type} ---")
    print(fmt.content[:200])

Automating It in CI on Release

The real payoff comes from never touching the changelog by hand again. Wire the generator into your release pipeline so that when you push a tag, the notes write themselves. The step below collects every commit since the last tag, pipes that git log into the Vincony unified client, and drops the drafted release notes into a file the release job can attach to the GitHub release.

# .github/workflows/release.yml — runs on tag push
- name: Draft release notes from git history
  env:
    VINCONY_API_KEY: ${{ secrets.VINCONY_API_KEY }}
  run: |
    PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
    RANGE="${PREV_TAG:+$PREV_TAG..}HEAD"
    git log --no-merges --pretty="- %s (%h)" "$RANGE" > commits.txt

    curl -s https://api.vincony.com/v1/chat/completions \
      -H "Authorization: Bearer $VINCONY_API_KEY" \
      -H "Content-Type: application/json" \
      -d "{
        \"model\": \"auto\",
        \"messages\": [{
          \"role\": \"user\",
          \"content\": \"Group these commits into a Keep a Changelog release for end users. Call out breaking changes.\n$(cat commits.txt)\"
        }]
      }" | jq -r '.choices[0].message.content' > RELEASE_NOTES.md

Because it runs on every tag, the notes are always in sync with what actually shipped, and the diff is reviewable in the same PR that cuts the release. Pair this with the CI/CD Pipeline Generator to scaffold the surrounding workflow, or see AI GitHub Actions for CI/CD for the full release-automation pattern. If you also publish an SDK, feed the same commit data into your API documentation pipeline so reference docs and changelog move together.

FAQ

Do my commit messages need to follow conventional commits? No. Clean prefixes like feat: and fix: make grouping trivial, but the model falls back to reading the diff and PR title when history is messy, so it still classifies stray or vague commits correctly.

Can it write both user-facing and developer-facing notes from the same release? Yes. Set the audience parameter and generate multiple outputs in one run — a plain-language summary for the release page and a technical appendix with breaking changes for your SDK consumers.

How do I keep AI costs predictable across many small releases? Route requests through Vincony's Developer API with a single key, and let the Smart Model Router pick a cheap model for tiny patch diffs and a stronger one only for major versions.

Get Started

5 changelogs/month on Free. Unlimited with CI/CD integration on Pro and Enterprise. Sign up for Vincony to get one API key across 800+ models and start drafting release notes straight from your git history.