Generative UI Is Solving a Problem Developers Don't Have
AI can now generate interfaces at runtime. The frameworks are impressive. The use cases remain unclear.
Generative UI is the pattern where AI agents create interface components at runtime instead of developers defining them upfront. The agent returns structured specs for cards, forms, and charts. The frontend renders them. Or the agent returns full UI surfaces that get embedded directly.
The frameworks are genuinely impressive. CopilotKit, MCP Apps, and the Open-JSON-UI spec all enable AI to output working interfaces. Figma Make generates responsive layouts from text prompts. The tooling has arrived.
I keep asking: who needs this?
The pitch involves AI agents that adapt their interfaces to user intent. Instead of navigating a fixed menu, you describe what you want and the agent generates the right controls. Instead of building a dashboard, you ask for one and it materializes.
This sounds good until you think about how people actually use software.
Users don't want interfaces that change. They want interfaces that become familiar. The value of a well-designed application is predictability. You know where the button is. You know what happens when you click it. Muscle memory compounds into efficiency.
Generative UI throws that away. Every interaction is potentially novel. The cognitive load never decreases. For tasks you do repeatedly, this is strictly worse than a static interface you've learned.
The response is usually "but for complex, one-time tasks..." and I'm not convinced there either.
If a task is complex enough to need a custom interface, it's probably complex enough to need a carefully designed interface. The difference between a form that's good and a form that's frustrating is subtle. Field ordering. Validation feedback. Default values. Error handling. AI can generate a form. It can't generate a form that accounts for how this specific user population makes mistakes.
Where generative UI might make sense: internal tools that serve long-tail use cases.
Enterprises have thousands of small workflows that don't justify custom development. Someone needs to query three systems, combine the results, and generate a report. Building a dedicated interface for that costs more than the workflow saves.
If an AI can generate a passable interface for that one-off task, the economics change. It doesn't need to be great. It just needs to be better than the alternative, which is usually a spreadsheet or a series of manual steps.
The widget builder trend fits here. Duda's AI assistant turns complex coding into conversations. You describe a widget and it writes the code. This is generative UI scoped to a reasonable problem: reducing the cost of building small interactive components for non-developers.
The distinction matters. Generative UI for novel, occasional tasks with low stakes? Useful. Generative UI as a replacement for designed interfaces in production applications? I don't see it.
The other angle worth watching is tokens and latency. Output tokens are slow and expensive. A generative UI framework that outputs a full interface spec for every interaction will be noticeably slower than one that serves prebuilt components. The best implementations collapse token-heavy processes into compact instructions that trigger predefined widgets.
Which starts to look a lot like the component libraries we already have, just with an LLM selecting between them. That's useful. It's also less revolutionary than the marketing suggests.
My prediction: generative UI becomes a feature of development tools rather than a replacement for designed applications. AI helps developers build interfaces faster. AI helps non-developers build simple interfaces at all. AI does not replace the concept of a designed, consistent interface for production software.
The frameworks are real. The capability is real. The revolution isn't.