When the User Interface Stops Being the Product
My wife was paying for a habit tracker app.
Nothing fancy - just a clean interface to track a few daily habits, check them off, maybe see some streaks. Like most modern apps, it was a subscription.
Out of curiosity, I tried rebuilding it using AI tools. It took less than an hour.
Same core functionality. Similar interface. No subscription. No onboarding flow. No design system. Just… done.
That was the moment something clicked. Not because I built something impressive, but because it exposed something uncomfortable: the interface wasn’t the product. It was just the easiest part to copy.
The UI Illusion
For the last couple decades, we’ve treated software as if the interface is the product.
The best companies won by designing cleaner dashboards, smoother flows, better interactions. If you were a frontend engineer - like I’ve been for most of my career - that was the work. The interface wasn’t just part of the system. It was the system, at least from the user’s perspective.
And it made sense, interfaces were expensive. You needed engineers, designers, time, iteration. That cost created a kind of built-in protection. You couldn’t just spin up a competing product overnight, even if the underlying idea was simple. So we internalized it: the interface is the product.
But that assumption is starting to break.
The Cost Collapse
It’s now trivial to generate interfaces.
You can take a screenshot of an app and have AI recreate it. You can describe a tool and get something functional in minutes. You can hook it up to real data with almost no friction.
I’ve seen this shift firsthand. At work, I’ve used AI to run SQL queries, generate dashboards, and spin up internal tools on the fly. Things that used to take days or weeks now take minutes. And it’s not just engineers doing this anymore - product managers are starting to do it too.
Once you experience that a few times, it’s hard not to ask a simple question: what exactly is the product here?
Because if I can recreate the interface, replicate the functionality, and tailor it exactly to my needs… what am I actually paying for?
The uncomfortable answer is that most software isn’t as unique as we pretend it is. A lot of it is just structured ways to read and write data. A habit tracker stores entries. A dashboard queries and visualizes metrics. A CRM manages records and relationships.
Historically, the structure - the interface - was hard to build, so it became the thing we packaged and sold.
Now the structure is cheap. Almost free.
And when something becomes cheap, it stops being where value lives.
Where Value Moves
You can already see the consequences of this starting to play out.
Instead of searching for the right tool, signing up, and learning its interface, you can increasingly just generate exactly what you need, use it, and move on. The “app” becomes less like a product you adopt and more like a temporary wrapper around some underlying capability.
Interfaces aren’t going away. But they’re no longer fixed. You don’t live inside them anymore. You invoke them when you need them, and they disappear when you don’t.
And once the interface becomes disposable, something else has to take its place as the source of value.
What’s left is what the system can actually do, and how easily that functionality can be accessed.
The capability itself - processing data, running workflows, integrating with other systems - starts to matter more than how it’s presented. And the way you access that capability - APIs, command-line tools, agent-friendly interfaces - becomes more important than the UI sitting on top of it.
In that world, the API isn’t just a supporting feature. It is the product.
This shift has real implications for how software gets built. The old model was to polish the interface, optimize onboarding, and design the perfect experience. The emerging model is to build something that works well at its core and can be easily invoked, recomposed, and reused.
That doesn’t make UX irrelevant. It just means it’s no longer where your moat comes from.
There are a lot of products today that are essentially nice interfaces over fairly generic functionality. That layer is getting thinner, fast. If your product can be screenshotted, described, and regenerated, then your defensibility was never really in the interface. It was just protected by how expensive that interface used to be.
This isn’t some distant future. It’s already happening in small, quiet ways - internal tools that never get formally built, dashboards that exist for a day and then disappear, simple apps replaced by one-off solutions.
Once you notice it, it’s hard to unsee.
We’re moving away from software you navigate toward software you invoke. When that happens, the interface stops being the product.
What’s left is simpler, and maybe a bit more honest: what your system can do, and how easily someone - or something - can use it.
And once the interface becomes trivial, it stops being the thing that matters.