The Great UX Rewrite — Why Everything You Know Is About to Expire

The Great UX Rewrite: Why Everything You Know Is About to Expire

The Train Wreck Hiding Behind the Demo

In March 2024, Klarna unveiled what they called an "AI concierge" — a customer service agent that, by their own metrics, handled two-thirds of all support traffic and shaved average resolution time from eleven minutes to under two. The press release was triumphant. The case study went viral. Nine months later, the same company walked it back, rehired humans, and posted a mea culpa about "lower quality" outcomes. The product was killed in less time than it took to build.

Klarna's AI wasn't bad. The model was good. The numbers were real. What was bad was everything around it: a customer journey still sculpted for an era when a human agent and a backend ticket system passed a thread back and forth. The AI was asked to imitate that structure, and in doing so it inherited every assumption the old UI had quietly been making — about who knows what, who decides what, and what "done" looks like.

That is the wiring problem I want to spend this chapter unpacking. Because Klarna is not an outlier. Klarna is the leading edge of a wave currently hitting every product team on Earth. The pattern repeats almost everywhere you look: a 2024-era model bolted onto a 2010-era interface, designed by a team whose instincts were trained in 2003. The result feels uncanny. Demo videos look magic. Daily usage feels like driving a Ferrari in a parking lot.

Here is the awkward truth: most product teams designing AI features in 2025 are still writing specs that look like CRUD apps with a sprinkle of autocomplete. They've added a chatbot. Maybe a sparkle icon. Maybe a "magic button" that summarizes a page. They have not reimagined the surface. They have not updated their model of what the user is, what the system is, or what the unit of design even *is*. And the consequence is showing up in revenue, in retention, and in the slow evaporation of competitive moats.

The thesis of this chapter is blunt. The AI revolution is not a feature drop. It is a platform shift, and platform shifts rewrite the interaction layer from the floor up. The last time the industry went through one — the mobile touch revolution of 2007 to 2012 — it took nearly a decade for the worst habits of the desktop web to be hunted down and replaced with patterns that actually fit a finger-tap-and-pinch world. We are at the start of the same cycle again, and we have less time this round, because the model is changing faster than the metal.

By the end of this chapter you'll have three things. First, a vocabulary for what's actually different about designing for AI-native products, distinct from every prior wave. Second, a way to look at any existing product — your own, your competitor's, the thing your CEO demoed last Tuesday — and see exactly where the old UI grammar is silently sabotaging the new AI capabilities. Third, a preview of the two poles — Copilot and Agent — that organize the rest of this book, along with the rich spectrum of products that live between them.

But before any of that, we have to get honest about how we got here.

Every Platform Shift Rewrites the Interaction Layer

Stand in any modern product meeting and listen for the phrase *just add AI*. It is the most expensive four-word sentence in software right now. It is also the natural, predictable, fully forgivable mistake of a generation of practitioners who learned their craft on a different substrate.

The pattern is consistent across every computing era. New substrate appears. The substrate gets a fresh coat of UI from the previous era. Things sort of work. Then they don't. Then a wave of new patterns arrive that are native to the substrate, and the old patterns get consigned to the legacy document. We are about thirty seconds into that second phase right now. The cringe is just beginning.

To understand how this plays out, it helps to look at the last five shifts in sequence, because each one teaches the same lesson: the technology stack can change radically without changing the design — until it does, all at once, and the gap between what the stack can do and what the interface exposes becomes the new competitive battleground.

```mermaid flowchart TD A["1970s: CLI<br/>Unit of design: Command"] --> B["1985: GUI<br/>Unit of design: Window"] B --> C["1995: Web<br/>Unit of design: Page"] C --> D["2008: Touch<br/>Unit of design: Screen"] D --> E["2020: Conversational<br/>Unit of design: Message"] E --> F["2025: Agents<br/>Unit of design: Outcome"] ```

Each row in that timeline is a different conversation between a human and a machine. Each one changed what designers treated as the smallest meaningful unit of work.

In the command-line era, the unit was the command. You learned the verbs. The computer either did the thing or printed an error. Power users loved it because the verb set was dense and composable. Everyone else bounced off because there was no affordance, only memorization.

The desktop GUI rewrote the unit from command to window. Pointing replaced typing. Menus replaced man pages. The Apple Macintosh and Microsoft Windows taught an entire industry that humans would rather recognize than recall, and that things live *somewhere* on the screen — in a region, behind a button — instead of as verbs you happen to remember. The unit of design was no longer a verb you invoked. It was a region you occupied. The mental model flipped from procedural to spatial.

The web moved the unit to the page. The link became the atomic gesture. Pages connected to pages, and the design problem became how to make each page know enough about where you'd come from and where you might go. Information architecture blossomed. Navigation patterns hardened. Search bars became religion. The unit was no longer a region on your own machine — it was a destination somewhere else's machine, reached by URL.

Mobile touch moved the unit to the screen — not the screen as a window into a document, but the screen as a context in your hand. The whole world web designers had built had to be re-fitted to a thumb, a portrait orientation, an accelerometer, a GPS sensor, and an attention budget of about eight seconds. Apps replaced pages. Gestures replaced menus. Notifications replaced the open tab. A "best practice" of 2009 — deep hierarchies, breadcrumb trails, ten menu items per page — became a suicide note in 2011.

Conversational interfaces, whose early public wave we can roughly date to 2020 with GPT-3 and the launch of ChatGPT, moved the unit again, this time to the message. A prompt is a sentence, and a sentence is a strange and wonderful artifact. It carries intent, but it is also full of ambiguity, framing, and tone that the system has to resolve. The implications were not that we would all just start typing questions into a chatbot. The deeper implication was that *intent itself* became the surface that designers had to grapple with. The interface disappeared into a text box. The grammar of interaction shifted from push-the-button to express-the-thought.

Each of those transitions felt, at the time, like a fashion change. In retrospect, each one changed what we even meant by *product*. A command-line utility is a tool. A GUI application is also a tool, but with a face. A web page is a document. A mobile app is a destination. A chatbot is a conversation. The thing we are now building — the agentic interface — is none of those. It is something else.

That something else is what this book is about.

But before we name it, we need to understand why the current crop of "AI features" mostly feel so awkward. The reason is not that the models aren't good enough. The reason is that the interaction grammar they're being dropped into is from the wrong era.

Why Probability Is a Wrecking Ball for Deterministic UI

Most UI conventions were designed for deterministic systems. You press the save button; the file saves. You click delete; the row goes away.