AI Made Building Software 10x Faster. Telling Anyone About It Is Still Stuck in 2015.

Something strange is happening in the software industry, and if you use any apps at all — and you do — it’s quietly affecting you.

Software is being built faster than at any point in history. AI coding assistants have compressed what used to take a team a month into something a single developer ships in a weekend. Products that once released updates quarterly now push changes daily. By any measure of raw output, we are living through the biggest acceleration in software production ever recorded.

And yet, as a user, you’d barely know it.

The app on your phone updates silently. The web tool you pay for every month adds features you never hear about. The bug that’s been annoying you for weeks? It was fixed twelve days ago — nobody told you. There’s a growing gap between what software companies build and what their users actually know about, and it’s becoming one of the odder inefficiencies in tech.

The bottleneck moved

For decades, the slow part of software was writing it. Everything else — announcing it, documenting it, telling customers — was a rounding error. When you ship four times a year, writing four announcements is easy. Companies built whole marketing rituals around the Big Release: the launch post, the email blast, the version number worth celebrating.

AI removed the writing-code bottleneck and, as bottlenecks do, the problem moved downstream. When a two-person startup ships thirty improvements a month, the constraint is no longer building. It’s communicating. Nobody has time to write thirty announcements. So they write zero.

The numbers behind this are real. Industry surveys throughout 2025 found the overwhelming majority of developers now using AI tools in their daily work, with release frequency climbing across companies of every size. Meanwhile, the way products communicate updates hasn’t structurally changed since the 2010s: a blog nobody checks, an email nobody opens, a “What’s New” page last updated three versions ago.

Why this actually matters

It’s tempting to file this under “mildly annoying,” but the consequences are bigger than they look.

For users, undiscovered features are money wasted. You’re paying for a product that solved your problem months ago — you just don’t know it. Studies of software adoption have found that a large share of features in business software go essentially unused, and poor communication of what exists is a major reason why.

For companies, it’s churn. Customers cancel subscriptions believing a product has gone stale when it’s actually improving weekly. In an economy where most software is rented rather than bought, the perception of momentum is survival. A product that ships constantly but communicates nothing looks, from the outside, exactly like a product that’s been abandoned.

For support teams, it’s a treadmill. Tickets pour in about problems that were already fixed, because the fix was never announced. The company pays twice: once to fix the bug, once to tell each confused customer, one at a time, that it’s fixed.

The obvious fix, and why it didn’t happen

The traditional answer to all this is the humble changelog — a dated, public list of what changed. Developers have kept them for decades. The problem is that a raw changelog is written by engineers, for engineers: “Refactored auth middleware, bumped deps, fixed race condition in job queue.” Accurate, and useless to a normal human.

Translating that into “You can now sign in with Google, and the app no longer freezes on upload” takes someone who understands both the code and the customer — and takes time nobody has. It’s the classic chore: important, never urgent, always skipped.

Which is why the fix arriving now is the same technology that caused the problem. If AI can write the code, it can read the code — and explain it. A new category of tools has emerged that watches a product’s actual code changes and automatically turns them into plain-English release notes. One example is ReleasePad, which connects to a company’s GitHub repository and uses AI to convert every batch of changes into a published, human-readable changelog — no writing required from the team. The pitch, essentially, is symmetry: AI got you into this communication debt, AI can pay it down.

Whether this specific category wins or the big platforms absorb the idea, the direction is clear. Release communication is following the same path code just took — from artisanal to automated.

The next readers won’t be human

There’s one more turn to this story, and it’s the most interesting one. Increasingly, the “user” reading about software updates isn’t a person at all.

AI agents — the assistants that book things, compare tools, and answer questions on our behalf — are becoming a real audience for product information. When you ask an assistant “does this app support X yet?”, the assistant has to find that answer somewhere. A current, well-structured, machine-readable changelog is exactly where. Products that publish clear update histories will be legible to this new agent layer; products that announce features only in tweet threads and marketing emails effectively won’t exist to it.

That flips the incentive entirely. Keeping users informed used to be good manners. Soon it’s infrastructure — the difference between being recommendable by machines and being invisible to them.

What to take from this

If you build software, the lesson is blunt: your shipping speed is now ahead of your speaking speed, and the gap is costing you customers who think you’ve stopped moving. Close it — automatically if possible, manually if not.

If you just use software, here’s a practical tip: find the changelog of the tools you pay for. It’s usually at /changelog or linked in the footer as “What’s New.” You’ll likely discover features you wanted and didn’t know you had — and you’ll learn more about whether a product deserves your subscription than any marketing page will tell you.

The software industry spent the last three years teaching machines to write code. The next couple will be about something more mundane and arguably overdue: teaching companies to simply tell people what they built.