Generative UI was the design world's big promise of 2025: interfaces that build themselves around each user in real time, no more one-size-fits-all screens. A year into the rollout, a lot of those interfaces don't feel like the future. They feel like shifting sand — buttons that move, layouts that reshuffle between visits, screens that behave differently than they did yesterday. The technology works. The experience often doesn't.

The watchout: The problem isn't that AI is generating the interface. It's that most companies are letting it generate too much, with too few rules. The fix isn't to abandon generative UI. It's to put guardrails around it before it quietly drives your customers away.

If someone on your leadership team needs to see this, forward it their way.

For most of computing history, a screen was something a designer built once and everyone saw the same way. Generative UI breaks that. Instead of serving a fixed layout, an AI assembles the interface on the fly, in response to what the user asked for or what the system thinks they need. Ask a financial app for a summary and it doesn't just return numbers — it builds you a custom chart, filtered to your question, in that moment. The interface is the AI's output, not a fixed thing the AI sits inside.

Google, which shipped its own version into its Gemini app and Search last year, describes the goal as a "rich, custom, and interactive user experience that adapts to any prompt." The logic makes sense on paper: a beginner and a power user need different things from the same product, so why give them the same screen? Let the interface mold itself to each person.

In the right place, this is genuinely useful. A complex analytics task compressed into one clean adaptive view beats making the user click through seven menus. A learning tool that reshapes itself around what a student is struggling with is better than a static textbook. When the interface adapts to what you're doing right now, it can take real friction out of the experience.

The trouble starts when companies decide that if a little dynamism is good, total dynamism must be better.

There's an unspoken agreement between a person and a piece of software. The "save" button is in the corner where it was yesterday. The menu opens the way it always opens. Tap the same place twice on two different days and the same thing happens. That predictability is not a limitation of old design — it's the thing that lets people actually use software without thinking about it.

This is the part the dynamic-design hype skipped over. As Paul Boag put it, the best parts of an interface are usually the boring parts. They're reliable. They let people build habits, then run on muscle memory. A regular customer stops reading your app and starts operating it — and that fluency is worth more to their experience than any clever per-session personalization.

Generative UI, pushed too far, breaks that contract. As the Nielsen Norman Group warned when the hype peaked, constantly changing interfaces create real usability problems, because so much of how people navigate software is rooted in consistency — the logo's in the top left, the cart's in the top right, the thing you clicked last time is where you left it. When the interface "evolves" every time someone shows up, you're not delighting them. You're making them relearn your product on every visit. Every reshuffled layout asks the customer to spend attention they didn't agree to spend.

Researchers studying these systems have a blunt way of putting it: a dynamic interface is not inherently valuable. It's only valuable when it adapts along an axis the user actually cares about. Movement on its own doesn't help anyone. It just makes the product harder to rely on.

Every business wants the "frictionless" experience — the one where the customer glides from intent to outcome without snags. Generative UI was supposed to deliver exactly that. Often it does the opposite, and it's worth being honest about why.

An unpredictable interface costs you in a chain. The customer hesitates, because they can't rely on what they learned last time. That hesitation turns into lost trust — they can't tell why the screen changed, or whether it'll behave the same way next time. And when something feels off, a layout they don't recognize or a flow that moved, a meaningful share of them just leave. That's not a knock on AI. It's how people have always responded to an environment they can't predict.

Does that mean generative UI is producing the highest bounce rates in app history? Honestly, nobody has clean industry-wide data on that yet — the technology is too new, and the companies seeing it happen aren't eager to publish the numbers. But you don't need a study to follow the logic. If predictability is what lets customers move quickly, and genUI removes predictability, the cost shows up where every experience problem shows up: people abandoning a task they came to finish. The question every product owner should be asking isn't "is our interface impressive?" It's "can a returning customer still find what they found last time?" For a lot of genUI deployments, the honest answer is no.

None of this means you have to rip generative UI out. A shifting mess isn't the only version available — the companies getting it right didn't turn the AI loose, they gave it a short leash. You don't need to be a designer to insist on that. You need to know what to require from your team or your vendor.

Generate from an approved kit, not from scratch. The AI should assemble interfaces out of a fixed library of pre-approved components — your buttons, your layouts, your patterns — not invent new ones every time. This is the single most important guardrail: the difference between an AI that arranges your branded furniture and one that redesigns the whole room while the customer is standing in it. Ask your team one question — is the AI choosing from our components, or creating its own?

Keep the anchors fixed. Navigation, logo, the cart, the primary action, the way someone reaches a human — these should never move, no matter how dynamic the rest gets. Decide which elements are load-bearing for trust and lock them down. Let the AI adapt the content inside the frame, not the frame itself.

Demand consistency you can test. Unconstrained generation can turn the same request into a different layout every time, which makes quality control impossible. Insist the same situation reliably produces the same experience. If your team can't test it, your customers are the test.

Adapt to the task, not the person. Adapting to what someone is doing right now earns trust. Rebuilding the interface around who you think they are, based on data they didn't knowingly hand over, feels less like service and more like surveillance. People want relevance, not the feeling of being watched.

Do that, and the business question answers itself. You're not in the business of the most impressive interface. You're in the business of helping a customer get something done and come back to do it again.

Dynamic isn't the goal. Reliable is. A customer who trusts your product to behave the same way twice is worth more than one who's briefly dazzled by an interface that reinvents itself.

Generative UI isn't failing customer experience. Ungoverned generative UI is. The difference is entirely in how much you're willing to rein it in.

A good interface works like a well-run shop. The regulars come back because they know where everything is — they can walk in, grab what they need, and leave without thinking about it. That familiarity isn't the boring part of the business. It is the business. Rearranging the shelves every night because some new system lets you doesn't feel innovative to the person trying to shop. It just makes them slower, then it makes them leave.

Generative UI is the same shelves, moved by an algorithm instead of a night crew. Use it to help your customer get to the checkout faster. Don't use it to move the aisles while they're standing in them.

Know someone making AI decisions who should be reading this? Forward it their way.

- Hashi