Skip to content

On a schedule

Write GitHub release notes from commits

When a new tag appears, readable release notes are written from the commits since the last tag and published on the release.

Runs
On a schedule
Apps
GitHub
AI
Yes, uses the built-in AI allowance
Access
Contents: read+write

Send this to your assistant

Create a ClickRuntime automation: when a new tag appears on acme/app, write release notes from the commits since the previous tag, grouped into features, fixes and other changes, and publish them on the GitHub release.

Paste it into your assistant. It tells you what it will send or change before it runs live.

First time? Adding ClickRuntime to your assistant takes about two minutes.

Why use it

Why teams use this automation

Cutting a release on GitHub usually ends with someone scrolling through forty commit messages like "fix typo" and "wip" to write the changelog by hand. It happens at the end of a long day, so the notes are skipped, copied from the commit log or so terse that users cannot tell what changed. Support then fields questions that a clear release page would have answered.

When a new tag appears, the run compares it with the previous tag and collects the commits and merged changes between them. ClickRuntime's built-in AI groups them into sections such as features, fixes and breaking changes, and the result is written into the GitHub release for that tag, either as a new release or an update to an existing one.

Maintainers of open source libraries and small product teams that ship often get the most from it, since the notes appear without anyone breaking their flow to write them.

What you get out of it

  • Every release has readable notes

    Users and customers get a grouped list of what changed instead of an empty release page, which cuts the number of questions about whether a bug was fixed in the latest version.

  • Breaking changes are called out

    Grouping commits makes a breaking change easy to spot under its own heading, so downstream users have a fair chance to read it before upgrading and filing an issue when their build fails.

  • Maintainers keep their evening

    Compiling a changelog from raw commits can take an hour on a busy release, and handing that to the AI draft means the maintainer only skims and corrects it. Reviewing a draft is far quicker than writing one.

  • Release pages stay consistent

    Each release follows the same structure, which makes the history easier to scan and gives anyone writing about your project, such as a blogger, an easy source of accurate information.

  • Compare range is exact

    Because the notes come from the diff between two tags and not from memory, nothing merged since the last release is forgotten and nothing from earlier versions is repeated. Late merges still make it into the right release.

How it works

What happens, step by step

  1. Every hour, the automation checks your GitHub repo for a new release tag.

  2. When it finds one, it collects the commits made since the previous tag.

  3. AI turns the commit messages into readable release notes, grouped into features and fixes.

  4. The notes are published on the GitHub release for that tag.

Before it runs live

  • Connect GitHub

What you get

RunsOn a schedule
Write GitHub release notes from commitstoday, 9:00Succeeded
GitHub · acme/app release v2.4.0## Features - CSV export for reports ## Fixes - Login redirect loop on Safari

Build your own

Need it to work differently?

This template is a starting point. Copy the prompt and change it, or describe a different automation from scratch, with your own conditions, more apps or an AI step. Your assistant writes it, tests it and runs it on ClickRuntime.
  • Your own rules

    Conditions, thresholds, filters and exceptions, written the way you'd explain them to a colleague.

  • Any number of apps

    One automation can read from one app and update several others. Over 248 apps are ready, and anything with an API works too.

  • AI where it helps

    Summaries, classification, extraction and drafts use ClickRuntime's built-in AI, with no extra key.

  • On a schedule or on each event

    Runs as often as every 5 minutes, or the moment an app sends an event, and keeps track of what it already handled.

Changes you can ask for

  • Act only on the items that match your own rules, and skip the rest
  • Change what the AI looks for, or how it writes the result
  • Add another app, for example also send it to Slack
  • Combine it with other GitHub steps into one automation

Under the hood

The code that runs this automation

This is the Python script that runs each time the automation starts. Your AI assistant writes it for you when you send the prompt, and you allow each step in your assistant. To change how the automation works, describe the change to your assistant and it updates the script for you. For every function it can use, see the script reference.
ai_release_notes_from_commits.pyexample
from clickruntime import on_trigger, credentials, http, ai, state, report_fetched

def gh(method, path, **kw):
    resp = http.request(method, f"https://api.github.com{path}", headers={
        "Authorization": f"Bearer {credentials.connection('github', 'work')}",
        "Accept": "application/vnd.github+json"}, **kw)
    resp.raise_for_status()
    return resp.json() if resp.content else None

REPO = "acme/app"

@on_trigger
def run(event):
    tags = gh("GET", f"/repos/{REPO}/tags", params={"per_page": 2})
    if not tags or tags[0]["name"] == state.get("last_tag"):
        report_fetched(0)
        return {"released": None}
    report_fetched(1)
    new, prev = tags[0]["name"], (tags[1]["name"] if len(tags) > 1 else None)
    commits = gh("GET", f"/repos/{REPO}/compare/{prev}...{new}")["commits"] if prev else []
    log = "\n".join(c["commit"]["message"].splitlines()[0] for c in commits)[:12000]
    notes = ai.generate(log or "Initial release", max_output_tokens=800,
                        system="Write release notes in Markdown with sections Features, Fixes and Other changes. Skip empty sections.").text
    gh("POST", f"/repos/{REPO}/releases", json={"tag_name": new, "name": new, "body": notes})
    state.set("last_tag", new)
    return {"released": new, "commits": len(commits)}

FAQ

Common questions

How does it know a new tag was created?
It remembers the latest tag it has already handled and checks the repository on a schedule. When a tag shows up that it has not seen, it treats it as a new release and compares it with the one before.
Does it need a GitHub Release to exist first?
No. If a release for the tag already exists, the notes are written into it. If not, a release is created for the tag with the generated notes. Either way you can edit the text on GitHub afterward.
Which token permissions does it need?
The token must be able to read the repository's commits and tags and to create or edit releases, which on a classic personal token means the repo scope. Tokens are kept as secrets, not written into the flow.
What permissions does it need?
Contents: read+write. Nothing else in your accounts is used.
Does it need AI?
Yes. It uses ClickRuntime's built-in AI, so you don't need an OpenAI or Anthropic key. Every plan includes a monthly AI allowance.
How many runs does it use?
One run each time it checks. Checks that find nothing new and stop right away aren't counted.
Can I change how it works?
Yes. Describe the change to your AI assistant, for example a different schedule, channel or filter. It updates the automation, tests it and tells you what changed.

Set up “Write GitHub release notes from commits” from your assistant

Copy the prompt above, or connect your assistant first. Free plan, no credit card.