It started while I was looking for a side project idea on Reddit. I came across a post in r/ProductManagement about automated, AI-generated release notes, got interested, and scrolled down to the comments. There, a comment from a Product Manager who works on release notes tools explained the idea far better than the post itself:
Automating release notes does not really mean that you handover full control to the Automation engine and run it on a auto-pilot. Automating release notes also does not really mean that you handover everything to the AI to take care of.
The comment splits the work into three parts — writing, drafting and distributing. Automation suits drafting and distributing, AI helps with the writing, and a person reviews and decides.
After reading it, I dove into research and started building. The result today is ReleaseFlow — the project page covers what it does. This post covers what the project page does not: ReleaseFlow is actually my second attempt at this idea.
The first version: AI Powered Release Notes Generator
The first version was called AI Powered Release Notes Generator. It was not a prototype: it really worked, and I wrote a few posts introducing it on social media.
But I felt it was still hard for people to get into. Following an early decision, the project was also split in two: an open-core module under the AGPL and an enterprise module under a proprietary licence, with templates, automation and distribution in the enterprise part.
It is a project I care a lot about, and at the time I felt it was incomplete — not yet the 100% I had in mind. So I decided to rebuild it, and this time to make it as complete and as proper an open-source project as I could.
Rebuilding it as ReleaseFlow: one module, one licence
When the rebuild started, the plan aimed for parity of function, not of structure with the old version. ReleaseFlow was a single Maven module, but I left open whether to split it into open-core and enterprise like before — if it ever needed to be commercialised, that would be decided at a later stage.
Almost two weeks later, on 22 September, I settled it in ADR-0029: the split was abandoned for good. I realised it really was unnecessary — no commercial plan needed that boundary, and maintaining a boundary for a plan nobody has is a cost with no payer. What I wanted was to make a small contribution to the people who actually need this tool, not to commercialise it. Templates, automation and distribution now sit beside every other feature, under the same licence.
That licence is Apache 2.0, not the AGPL of the old open-core module, for three reasons:
-
it is the licence of the ecosystem ReleaseFlow is built on — Spring Boot, Spring Security, Flyway, Micrometer and Testcontainers are all Apache 2.0;
-
nothing in the dependency tree forces copyleft, so the choice was genuinely free;
-
Apache 2.0 grants patent rights explicitly, which MIT does not.
Alongside the licence come the other things an open-source project needs:
NOTICE, CONTRIBUTING.md, CODE_OF_CONDUCT.md, SECURITY.md, a
CHANGELOG.md following Keep a Changelog, and a documentation site in English
and Vietnamese.
The hardest part came before any code
The hardest phase for me was the first one: understanding how the product should work, what it should do, and how to architect it without falling into over-engineering. For a tool that can connect to a dozen different systems, it is very tempting to design for everything from day one.
Looking back at the Architecture Decision Records, the project started much smaller than it is now:
-
At first, each Project connected to exactly one GitHub repository. The shared abstraction for sources was only extracted when a second source — GitLab — actually arrived; Linear and Jira followed right after.
-
AI started as OpenAI only, ran only when someone clicked, and every AI result had to be reviewed. Three days later that decision was superseded: if every change the AI touched needs a review, automatic AI is pointless. Instead, the rules and the review triggers keep the authority, and the AI runs automatically and only suggests.
-
No message broker. All background work runs on PostgreSQL itself with
FOR UPDATE SKIP LOCKED— one database for both the data and the queue.
Two weeks for features, almost a month to make it usable by anyone
The first ADR was recorded on 9 September 2026. By 22 September there were 29 — almost every feature of the product. Yet v1.0.0 only arrived on 20 October.
The month in between went to things that are not features: a quickstart bundle to try it with a few commands, a release pipeline that publishes the JAR, the image, an SBOM and checksums automatically, and the documentation site. That is exactly what the first version lacked — the part that lets other people get into the project.
Mocks are not enough: testing for real on dbvault
At first I tested with mocks. But a mock only answers the questions you already thought of, so it did not feel close enough to reality. I looked into it and planned real-world testing on one of my own projects.
That project is dbvault. It started as my take on the Database Backup Utility project on roadmap.sh, finished a long time ago. I reused it as a real lab for ReleaseFlow: repositories on GitHub and GitLab, a project in Jira, and real pull requests, merge requests and issues.
And that lab found a problem no mock ever would. Jira issue DBV-44 described a CLI bug, and merge request !9 was the change that fixed it. Both entered ReleaseFlow as separate changes, but only the merge request belonged in the release note. Rejecting DBV-44 during review just offered it again to the next release, and the one after. The only way to keep it out was a placeholder draft — ugly, and something anyone could publish by mistake.
That became the last feature before v1.0.0: excluding a change from every release, with a reason, without deleting anything.
The biggest surprise was that everything else worked almost exactly as I had imagined. Not 100%, but as far as I am concerned it is now ready for people to use reliably.
Working with an AI coding agent
I used an AI coding agent throughout, but always under my control: the agent
works from a guide that lives in the repository (AGENTS.md), and every major
decision is recorded as an ADR.
What the agent did really well was writing documentation from the ideas I discussed with it. What I had to fix the most were the problems that only surfaced in real testing with dbvault. That is also where I spent the most time supervising — to know for sure that each feature did its job, and whether anything went wrong in practice.
It is the same idea behind ReleaseFlow itself: AI drafts, and a person checks and decides.
What’s next
To see what ReleaseFlow does and how to try it, head to the project page. In the coming posts, I will go deep into the technical decisions one at a time:
If you try it and hit a problem, or think something is missing, open a Discussion on GitHub — that is the most useful contribution to me right now.