Best release-notes generator from commits and PRs?

If you mean “take my merged commits/PRs and produce polished release notes automatically,” my pick is Release Drafter for GitHub-based projects.

Best options

• 🥇 github.com — Best overall for GitHub. It continuously builds a draft release as PRs merge, supports categorization, labels, SemVer-based version suggestions, contributors, and custom Markdown templates.
• 🥈 GitHub's built-in generated release notes — Best if you want zero setup. Good for straightforward projects, but less customizable.
• 🥉 AI-based generators — Better if you want notes that say “Added OAuth login for enterprise customers” rather than simply “feat: add OAuth endpoint (#123)”. They're preferable when your PR titles/descriptions are inconsistent.

What I'd choose

One important distinction: Release Drafter primarily generates from PRs, not raw commit messages. It can associate commits with PRs and uses PR metadata/authors in the generated release.

If you tell me GitHub/GitLab + whether you want AI-written summaries, I can give you the best 3 tools specifically for your workflow.

The "best" tool for generating release notes from commits and PRs depends heavily on whether your audience is developers (needing internal markdown/changelog files) or end-users/stakeholders (needing polished, human-readable updates).

The top options on the market fall into distinct categories based on your workflow:

1. Best for Automated GitHub Releases & PR Labeling: Release Drafter

• How it works: Continuously drafts your next release notes as pull requests are merged into your default branch, categorizing them based on PR labels (e.g., bug, enhancement, breaking-change).
• Pros: Doesn't strictly force your team to write strict Conventional Commits—relying on PR labels makes it very forgiving for human contributors.
• Cons: Doesn't handle semantic version bumping for you.
• Get started: Check out the Release Drafter Action on GitHub Marketplace.

2. Best for Strict Semantic Versioning & Conventional Commits: Release Please

• How it works: Developed by Google, Release Please parses your commit history (using Conventional Commits) to automate semantic version bumps (major, minor, patch) and opens a "Release PR" for you to review before officially publishing.
• Pros: Handles versioning and changelog generation hand-in-hand; supports 20+ languages and monorepos out of the box.
• Cons: Requires strict team discipline around commit message formats.

3. Best for Local / CLI / Non-GitHub Git Workflows: git-cliff

• How it works: A high-performance changelog generator written in Rust that pulls directly from git history. It uses custom regex and a cliff.toml configuration file to turn arbitrary commit messages into structured markdown.
• Pros: Blazing fast, highly customizable, and platform-agnostic (works with GitLab, Bitbucket, or raw local git repos).
• Cons: Requires writing custom configuration rules for your preferred output format.
• Get started: Explore the project via the git-cliff GitHub repository.

4. Best AI-Powered & Customer-Facing Polish: PersonaBox / AutoChangelog Tools

• How it works: If raw developer commits ("fix typo in auth.ts") look too messy for customers, AI changelog tools ingest your PRs/commits and automatically rewrite them into customer-friendly feature summaries.
• Pros: Translates dense engineering jargon into engaging, value-driven product release notes with optional branded pages.
• Cons: Paid tools or requires connecting third-party AI keys/services.

To help narrow down the ideal tool, tell me:

• Are your target readers developers or end-users?
• Do you use GitHub, GitLab , or another platform?
• Does your team already follow Conventional Commits or use PR labels?

If you mean “take merged PRs + commits and turn them into polished, human-readable release notes”, my picks are:

1. github.com — best overall for GitHub

• AI analyzes PR titles, bodies, labels and diffs, rather than blindly rewriting commit messages.
• Supports custom style instructions and flags uncertain entries for review.
• Particularly good if you want release notes that explain what changed rather than merely listing PRs.

2. release-notes.dev — best simple dedicated tool

• Connect GitHub, select a tag/branch/commit range, and generate categorized Markdown.
• Also offers hosted changelogs and webhooks.
• Very low setup overhead.

3. github.com — best non-AI/CI option

• Continuously maintains a draft release as PRs merge.
• Excellent label-based categorization, version suggestions, exclusions, and GitHub Actions integration.
• Less “rewrite this into customer language,” more deterministic automation.

4. GitHub's built-in release notes — best zero-dependency option

• GitHub automatically gathers merged PRs, contributors, and the changelog.
• .github/release.yml lets you categorize/exclude PRs.
• The downside: it doesn't really rewrite developer-oriented PR titles into polished customer-facing prose.

5. github.com — best for conventional-commit pipelines

• Very mature if your repo already uses Conventional Commits + semantic-release.
• Deterministic rather than AI-generated.

My recommendation

For a modern GitHub team, I'd choose Copilot Release Notes if you want quality, or Release Drafter if you want predictability and zero AI dependence.

The important distinction is PRs vs. commits: PRs generally contain much richer context, so an AI tool that can inspect PR descriptions/diffs will usually produce substantially better customer-facing notes than one that merely summarizes git log.

If you tell me your stack (GitHub/GitLab, SaaS vs self-hosted, AI allowed or not, and whether you need Slack/Jira/Confluence/changelog publishing), I can narrow it to the best 2–3.

The "best" generator depends on whether your target audience is developers (internal/open-source markdown) or customers (polished product updates), and whether you rely on Conventional Commits or PR labels.

The top tools split into clear categories based on how they handle your workflow:

1. Release Please (Best for automated semantic versioning & mono-repos)
   • How it works: Parses your commit history (using Conventional Commits) and opens a persistent "Release PR" in your repo. When you merge that PR, it bumps versions, updates the CHANGELOG.md , and cuts a GitHub release automatically.
   • Best for: Teams practicing strict conventional commits who want a hands-off, dependable release cycle without managing manual tagging.
2. Release Drafter (Best for PR label-based workflows)
   • How it works: Runs as a GitHub Action and continuously drafts your next release notes as pull requests are merged, categorizing them dynamically based on your PR labels (e.g., bug, enhancement, breaking-change).
   • Best for: Teams who forget to write clean commit messages but are good at labeling their pull requests.
3. git-cliff (Best for high customizability & speed)
   • How it works: A blazing-fast CLI tool written in Rust that generates changelogs from git history using customizable Jinja2/Django-style templates. It doesn't force a specific workflow on you and can parse almost any custom commit convention.
   • Best for: Developers who want total control over the exact layout, styling, and categorization of their raw markdown changelogs.
4. GitHub's Built-in Release Notes Generator (Best out-of-the-box zero-setup)
   • How it works: Built right into GitHub. When creating a release, clicking "Generate release notes" automatically groups merged PRs by label and author categories.
   • Best for: Simple projects that don't need complicated CI/CD pipelines or customized configuration files.

If you want to narrow this down, let me know:

• Do you use Conventional Commits (feat/fix prefixes) or PR labels?
• Are the release notes meant for developers (markdown/GitHub) or end-users (a public product changelog page)?

If you mean “take my merged commits/PRs and automatically turn them into polished, user-facing release notes,” my current picks are:

My recommendation

For a typical GitHub product, I'd start with release-notes.dev. It connects directly to GitHub, can consume commits, PRs, and tags, automatically groups changes, and produces Markdown or a hosted changelog. It explicitly says conventional commits aren't required because its AI can handle free-form commit history.

If you want deterministic, CI-native automation rather than AI, use Release Drafter. It maintains a draft release as PRs are merged and lets you categorize changes based on labels, assign SemVer increments, exclude internal changes, etc.

For a JS/TS monorepo, I'd lean toward Changesets: its GitHub changelog integration can link generated entries directly to the relevant commits, PRs, and authors.

Short version:

• 🤖 Best AI: release-notes.dev
• 🧱 Best reliable GitHub CI: Release Drafter
• 📦 Best monorepo: Changesets
• ✍️ Best “paste commits → polished copy”: ChangelogAI

If you tell me your stack (e.g. GitHub + conventional commits + npm, or GitHub + Jira + Slack), I can narrow it down to the best 1–2 options.

The "best" release-notes generator depends heavily on your team's workflow discipline (do you use PR labels? Conventional commits?) and your audience (are the notes for developers or end-users?).

The top tools available are categorized below by how they handle your commits and PRs:

1. Best Native & Zero-Config (For GitHub-centric teams)

• GitHub Built-in Release Notes Generator: GitHub Releases has native generation built directly into the UI and API (generate_release_notes: true). It compiles all merged PR titles, labels, and authors since the last tag.
  • Best for: Open-source projects or teams that want a free, zero-maintenance log.
  • The catch: Output quality matches the quality of your PR titles . It lives in the GitHub UI rather than a clean CHANGELOG.md file.

2. Best for Strict Label/Template Customization

• Release Drafter: A popular GitHub Action that continuously drafts your release notes as pull requests are merged, organizing them by labels (e.g., feature, bug, dependencies).
  • Best for: Teams that diligently label their PRs and want clean categorization before hitting publish.
  • The catch: Stays engineer-facing by default unless you manually clean up the copy.

3. Best for CI/CD & Monorepos (Conventional Commits)

• semantic-release: Fully automates your entire release workflow by analyzing commit messages (using Conventional Commits like feat:, fix: ) to determine version bumps, generate changelogs, and publish packages.
• Changesets: The gold standard for JavaScript and TypeScript monorepos . Contributors write a tiny .md changeset file alongside their code changes, which the tool aggregates into clean version bumps and changelogs.
  • Best for: Libraries and complex codebases where CI/CD automation handles versioning.
  • The catch: Requires strict team buy-in on commit message formatting or changeset files.

4. Best AI-Powered Translators (Developer-speak to Customer-ready)

• Changesmith: Connects as a GitHub app, looks at your git history between tags, filters out noisy dependency bumps/refactors, and uses AI to turn raw commits into readable plain-language markdown.
• ReleaseGlow: Pulls PR titles, descriptions, and commits upon merge, uses AI to classify features/fixes, and outputs a draft ready for human review before publishing to a public changelog, email, or Slack.
  • Best for: Product managers and teams who want to skip rigid commit conventions and instantly generate user-friendly copy from messy PRs.

If you'd like to narrow this down, tell me:

• What git hosting platform do you use (GitHub, GitLab, Bitbucket)?
• Do your developers follow Conventional Commits or standard PR titles?
• Do you need these notes to be customer-facing (plain English) or internal/technical?

If you mean “take merged PRs + commits and produce genuinely readable, customer-facing release notes”, my picks in 2026 are:

My recommendation

For most SaaS/product teams: release-notes.dev. It explicitly combines commits, PRs and tags, groups changes, produces AI-assisted summaries, and can export Markdown or host the changelog.

If you want zero AI and maximum GitHub-native simplicity: Release Drafter is excellent. It continuously builds a draft release as PRs merge, with labels controlling categories.

If you're already heavily invested in conventional commits and automated versioning: use semantic-release. Its release-notes generator is mature and generates notes from commits since the previous release.

One important distinction: GitHub's own generated release notes are surprisingly good if you just need a PR/contributor summary—they automatically include merged PRs and contributors and let you categorize PRs with labels. docs.github.com But they're less useful if you want AI to translate engineering language into “why customers should care.”

If you tell me your stack (GitHub/GitLab, Jira/Linear, conventional commits or not), I can narrow this to the best 1–2 options.

The best release-notes generator depends on whether you need raw technical markdown for developers or polished, plain-English updates for customers. Top options include Google's Release Please for strict conventional commits, git-cliff for high customizability, and AI-driven tools like PersonaBox or Changesmith for customer-facing narratives.

Developer-Facing & Conventional Commit Tools

• Release Please : Automates the release process by parsing commit history, creating a "Release PR" that updates your CHANGELOG.md , and bumping versions.
• git-cliff : A fast, highly configurable command-line tool written in Rust that uses custom parsers and TOML configuration files to generate tailored changelogs from git tags and commits.
• semantic-release : Fully automates the package publishing and changelog creation workflow directly from your CI/CD pipeline.

AI-Powered & Customer-Facing Tools

• PersonaBox : Parses GitHub pull requests to generate styled, customer-ready release notes complete with auto-generated visuals and hosted announcement pages.
• Changesmith : Connects via a GitHub App to analyze raw commit and PR ranges, translating rough developer notes into clean markdown without forcing your team to adopt rigid commit conventions.

If you can share whether your target audience is internal developers or external customers , and whether you already use Conventional Commits , I can recommend the exact setup or GitHub Action for your workflow.

If your source of truth is GitHub commits + PRs, my picks are:

My recommendation

For a modern SaaS/product team: use an AI PR-based generator. PR descriptions generally contain much more useful context than commit messages, and recent research also finds LLM-based approaches outperform traditional commit-only approaches.

For engineering-only changelogs: Release Drafter is probably the sweet spot.

For polished customer-facing release notes: release-notes.dev is the one I'd try first.

For maximum control / no SaaS dependency: git-cliff.

If you tell me your stack (GitHub/GitLab, monorepo or not, Conventional Commits or not, and whether notes are internal vs customer-facing), I can narrow it to the best 1–2 options.

The "best" generator depends heavily on your team's workflow discipline (e.g., whether you strictly use Conventional Commits) and who the final audience is (developers vs. end-users/customers).

1. Best for Strict Conventional Commits & CI/CD Automation

• semantic-release / Release Please
  • How it works: Analyzes your commit messages (using standard prefixes like feat:, fix:, perf: ) to automatically determine semantic versioning bumps, generate a CHANGELOG.md , and publish releases.
  • Best for: Open source libraries and engineering teams who want a fully hands-off, deterministic release pipeline.
  • Pros: Zero human intervention required on release day; highly reliable if commit guidelines are strictly enforced.
  • Cons: Fails or looks messy if contributors ignore your commit conventions.

2. Best Highly Customizable Open-Source CLI / Action

• git-cliff
  • How it works: A blazing-fast changelog generator written in Rust that uses Handlebars templates to parse git history. It can group, filter, and format commits based on custom configuration files.
  • Best for: Teams who want total visual and structural control over their markdown changelogs without being locked into a rigid ecosystem.
  • Pros: Incredibly fast, handles massive repos with ease, and supports custom regex parsing for non-standard commit messages.
  • Cons: Steeper learning curve for writing the configuration templates.

3. Best Out-of-the-Box & Free (GitHub Native)

• GitHub Releases "Auto-generate release notes"
  • How it works: Built right into the GitHub UI and API. When drafting a release, clicking "Generate release notes" automatically pulls in merged PR titles, handles contributor shout-outs, and organizes items by labels. Pair it with Release Drafter to keep a live, running draft updated via PR labels automatically.
  • Best for: Teams already operating entirely inside GitHub who want a clean internal record without installing external third-party services.
  • Pros: Free, native, zero maintenance.
  • Cons: Outputs raw engineering speak ("bump deps to v4.2.1") rather than customer-ready copy.

4. Best AI-Powered / Customer-Facing Generators

• Changesmith / ReleasePad /
  • How it works: These tools hook into your GitHub repository, read raw PR descriptions and commits (without requiring strict conventional commit formatting), use an LLM to filter out noise like dependency bumps, and rewrite the changes into plain, reader-friendly prose.
  • Best for: Product and SaaS teams who need to turn messy git history into polished, customer-facing updates or email digests.
  • Pros: Saves hours of manual editing; bridges the gap between technical commits and human-readable product updates.
  • Cons: Paid options past basic tiers; you must review AI-generated text before publishing.

To help narrow down the ideal choice, tell me:

• Do you enforce Conventional Commits (e.g., feat:, fix: ) in your team?
• Are these release notes meant for internal developers or end-users/customers?