The Bottleneck Moved

With AI, teams are shipping software faster than ever.

For customers, that means more change, arriving more often, with less warning than they used to get.

Which puts product communication at the top of the priority list again with Product and Ops teams. (Customers can absorb a remarkable amount of change when somebody explains what’s changing, and why!)

One good update takes four things: knowing what went out, why it changed, who asked for it, and what it looks like.

AI can write an update in seconds. But the gathering is still by hand, spread across Jira, GitHub, meeting recordings, and Slack — and it seems like there’s more with every release.

Multiply that across multiple products and teams, and you land where most teams are right now — shipping at machine speed, still communicating at “human speed.”

Feel familiar?

Measure your ship-to-story lag

Pick your last release. Time how long it takes you to answer four questions.

• What changed. Does the ticket still describe what shipped, after scope moved twice?
• Why it changed. The tradeoff, which usually lives in a recording or somebody's head.
• Who asked for it. The customer, the deal, the feedback that started the work.
• What it looks like. A screenshot, a demo, thirty seconds of video.

Add it up and you have your lag — the distance between when your team ships and when anyone outside it can understand what happened.

That number is the one part of your pipeline AI hasn't touched yet.

No single system holds all four answers. Each one lives where it was created — the repo, the ticket, the meeting recording, the screenshot — so a person walks the whole loop by hand, every release.

At LaunchNotes, we weren’t immune either! The gathering is still the bottleneck.

So we went after the busywork

At LaunchNotes, we’ve spent years on the telling — powerful customization options, a page to tell your story, email, embedded widget, rich notifications. Communicating change is what we're good at.

So we took a hard look at our own process, then started digging into how our customers run theirs.

Same answer every time: the work before the writing. Meetings, demos, Slack threads, tickets waiting to be sorted — all manual, and all of it exactly what a machine should be doing.

That's where the last few months went: Solving this problem from multiple angles. Figuring out ways to hand the fetching to the agent and keep the judgment — what's worth telling customers, and how — up to the human.

Two ways to connect your universe

Come to us and use our AI. Smart Draft takes Jira tickets, a Confluence page, a Loom, a PRD as a file, or a rough prompt in your own words. You point at the sources and our model writes the draft.

Templates carry the shape. Your sections, categories, and roadmap links are set before the model writes a word, so nobody spends the editing pass turning AI prose into your format.

Or bring us into your AI. The customer pull for this showed up before we were ready. We shipped a beta MCP connector in January and teams arrived with Jira, GitHub, Intercom, and Pendo already connected, asking why LaunchNotes wasn't on that list.

Now it is. Our MCP connector puts LaunchNotes inside Claude Code, Claude Desktop, claude.ai, and Cursor — twenty-nine tools and eight skills behind one install.

You sign in with your LaunchNotes account and the assistant acts as you, with exactly the permissions your role already has. No tokens to generate or rotate. It runs on your model and your usage, so security has no new AI vendor to review.

In practice it sounds like this: "We closed the 2.4 milestone in Jira. Draft the release note." The agent pulls the closed issues, checks what's already been announced, writes it in your voice, tags the categories, attaches every source issue, links the roadmap item, and leaves a draft in LaunchNotes.

Or "What are customers asking for? Put the top themes on the roadmap." It clusters your feedback from LaunchNotes and other tools, shows the volume behind each theme, and creates roadmap items so your customers feel heard.

Make it a workflow your team runs

A skill is a playbook your agent follows. You describe the outcome and it runs the steps.

We ship eight of them with the LaunchNotes MCP as a Plugin — drafting from tracker work, clustering feedback into roadmap items, posting roadmap updates that notify followers, recapping how a release performed. They're all readable on GitHub, and worth a look even if you never install one, because they show what a release workflow looks like when somebody finally writes it down.

The ones teams build themselves reach further across their own stack. A release workflow usually goes: pull the closed issues from the Jira milestone, cross-check them against merged PRs so nothing that shipped quietly gets missed, apply the team's tone rules and release-note structure, then create the draft in LaunchNotes with every source issue attached and the roadmap item linked.

One instruction, four systems.

Then the real leverage: One person writes the workflow down, saves it where everyone can reach it, and it stops being that person's job. Every team can run the same steps and get the same result without knowing how any of it is wired.

Pro tip: agents read your tickets now. All of this runs on what your team leaves behind. Ticket hygiene was always good practice, and it's now the input your agent reads before it writes a word. The small things pay off immediately. Labels that mean something. A workflow that moves the ticket when the PR hits staging. A comment noting what's behind a feature flag, so nothing gets announced before customers can actually see it.

Pro tip: write your voice down. You still need to handle the eight people across four products sounding like different companies, and hoping each of them prompts well. The teams who handle that well have their voice written down somewhere a machine can read it — a Confluence page, a skill, the Tone & Voice setting in LaunchNotes. Where it lives matters much less than the fact that one version of it exists. Write it once: who you're writing for, how you sound, what rules always apply. Then every draft inherits it, whether it starts in our editor or in somebody's agent.

Let AI do the work. You bring your taste.

Every one of these paths ends at a draft, deliberately.

Hand over the fetching, the cross-referencing, the formatting, the category tags. None of that has ever been the reason a release note was good.

What's left needs you: Whether this is the right thing to tell customers this week. Whether the framing lands for the account that's been waiting on it. Whether the tone fits the quarter your team just had.

That's taste, and it's the job. You get the twenty minutes back and spend them on judgment instead of assembly.

Shipping is only speeding up

The only thing we should say with confidence at this point with AI: This is not it; everything will get smarter, faster, and better.

AI took the writing first. Two years of pasting tickets into ChatGPT and cleaning up what came back. Then it took the code, and plenty of us are still cleaning up after that too.

Your taste was always part of the deal, in both places. What changed is the pace — the build side moves at twice the speed it did, and nothing downstream of it was designed for that.

Everything in between — the meetings, the demos, the ticket sorting — is where the revolution is happening with product teams right now.

And if you want to compare notes, I’m always game! The best conversations we're having right now are with teams who are trying to wire their stack together and optimize for the future.