In the first piece in this series I drew a line between bolt-on AI and AI-native software, and near the end I raised something almost in passing: when a system is built for AI to operate, the interface itself starts to change. That's the part I want to sit with here — because it's the part you'll actually feel, and the part that's easiest to get wrong.
The quiet tax of the interface
For as long as we've had software, using it has meant learning where the buttons are. Every new capability arrives as another screen, another menu, another form to fill in the right order. The power is real, but it's gated behind knowing the path. We've all watched a genuinely capable platform sit half-used because most people never found where its depth was hidden.
That's the quiet tax of software. The interface isn't just how you reach the power — it's the ceiling on who can reach it, and how fast. You don't pay it in dollars. You pay it in onboarding, in "let me show you where that is," in features nobody ever discovered.
Two ways to tell software what you want
There have really only ever been two ways to tell a computer what you want.
The first is to follow a path someone else designed — the menus, the forms, the wizard steps. Every one of those encodes assumptions about how you'll work, made by people who couldn't know your exact situation. You adapt to the software.
The second is to say what you want and let the system work out the path. You describe the outcome; it handles the sequence. The software adapts to you.
For decades, only the first was possible — because software couldn't understand the second. That's the constraint that just lifted.
What that actually looks like
Let me make it concrete — and I mean these as illustrations of a principle, not a description of any one product.
The first way looks like this: open the catalog, filter by category, filter by supplier, filter by decoration method, sort by price, open a product, configure it, add it to a store, repeat, then build the store, then set pricing, then publish. A dozen screens, in the right order.
The second way looks like a sentence. "Find a sustainable navy polo under $15, put this client's logo on the left chest, and build them a store for their sales team." Or: "Which of my stores lost momentum last quarter, and what changed?" — a report you ask for rather than one you assemble. Or: "Duplicate this store, swap in the new catalog, and rebrand it for a different client."
The distance between "I want this" and "this is done" collapses. Not because you finally learned the software. Because you no longer have to.
The screens don't go away
Here's where I want to be careful, because this is where the hype gets it wrong. This is not "chat replaces the interface." Anyone who has tried to do everything through a chat box knows some things are genuinely faster as a button, a table, a drag. A blank text field is not a better way to pick a color.
So the screens don't go away. Intent becomes a second way in — a faster path alongside the one you already know, for the moments and the people it suits. Some will live in it. Some will never touch it. Most of us will move between the two without thinking about it, the way we already switch between typing a search and clicking a bookmark.
The title of this piece is the whole point: AI as the new interface, for those who want it. Optionality isn't a caveat here. It's the design.
Who it's really for
And that optionality is exactly why this matters more than a productivity trick. The biggest thing an intent-based interface changes isn't speed for the expert — it's access for everyone else. The rep who started Monday. The occasional user who logs in twice a month and forgets where everything lives. The client you'd love to hand a little self-service to, but never could, because the tool was too much to teach.
When the interface stops being a map you have to memorize, the platform's depth stops being reserved for the people who memorized it.
The software's ceiling stops being "how much can you learn," and becomes "what can the system actually do."
Those are very different ceilings.
The part that stays human
None of this touches the part of the business that actually matters — which was where I ended last time, and it bears repeating. Intent removes the friction of operating the software. It does not remove the judgment, the taste, or the relationship.
For anything that carries weight — pricing, a client's brand, a live store — the pattern isn't "AI does it and you find out later." It's the one from the first piece: the system proposes or executes, and a human decides. You stay in the loop exactly where being in the loop counts, and you skip it where it never did.
That isn't a hedge against the technology. It's the intent behind it. The goal was never to take people out of the work — it was to take the software out of the way of it. It's the same thread running through everything we've written about removing the manual cost per order and why more stores shouldn't mean more work.
What has to be true first
There's one piece missing to make any of this real, and it's the one I keep pointing at. For intent to be a genuine interface, the system's actual operations have to be reachable by AI in the first place — and, ideally, not only by the platform's own assistant, but by the AI tools you already use every day. That's the open part of the story, and it's what I'll get into next.
The interface is the oldest constraint in software, and the most visible. It's about to become optional. Not gone — optional. For those who want it.