What Is Generative UI?

> Users get personalized interfaces without custom code.

Personalized interfaces are bad. I don't want to configure anything, and I don't want anything automatically configured on my behalf. I want it to just work; that kind of design takes effort & there's no way around it.

Your UI should be clear and predictable. A chatbot should not be moving around the buttons. If I'm going to compare notes with my friend on how to use your software, all the buttons need to be in the same place. People hate UI redesigns for a reason: Once they've learned how to use your software, they don't want to re-learn. A product that constantly redesigns itself at the whims of an inscrutable chatbot which thinks it knows what you want is the worst of all possible products.

ALSO: Egregiously written article. I assume it's made by an LLM.

The case against complex UI hides the fact that nobody wants to take their time to learn a piece of software anymore. Attention spans are so short, if the system doesn't do all the thinking for you, why bother with it? We are just moving the human laziness through another layer of indirection. The fact never changed in the past 30 years: some domains are complicated and you need smart people on both ends who can bridge the gaps. The dream has always been the same with nocode, lowcode and whatever, it doesn't change this fundamental flaw.

Consider building your own blender software. If you know nothing about 3D you start off in your language and the LLM will happily produce UI for your level of understanding, which is limited. Over time you will reach an understanding that looks just like the software you were trying to replicate.

Currently the ecosystem around UI changes so much, because its always been a solved problem that people just keep reinventing to have... something to do I guess?

On the face of it, this seems like a terrible idea. Interesting, but terrible. I’ve spent 30 years encouraging simple, repeatable, user-focused UI’s where hierarchies are explicit, pages are referenceable, search results are real URLs and so on. Randomness is generally bad - humans expect X module or block or whatever to be in the same place from visit to visit, not adapting based on some complex algorithm that “learns”.

UX and UI takes work, and it’s mostly work getting back to simplicity - things like “think more like a user and less like your organisation” in terms of naming conventions and structures, or making sure that content works harder than navigation in orienting users. I don’t think there’s any sort of quick fix here, it’s hard to get it right.

Simplicity is surprisingly complex :-)

I bristled at the title, article contents, and their spreadsheet example, but this does actually touch on a real paint point that I have had - how do you enable power users to learn more powerful tools already present in the software? By corollary, how do you turn more casual users into power users?

I do a lot of CAD. Every single keyboard shortcut I know was learned only because I needed to do something that was either *highly repetitive* or *highly frustrating*, leading me to dig into Google and find the fast way to do it.

However, everything that is only moderately repetitive/frustrating and below is still being done the simple way. And I've used these programs for years.

I have always dreamed of user interfaces having competent, contextual user tutorials that space out learning about advanced and useful features over the entire duration that you use. Video games do this process well, having long since replaced singular "tutorial sections" with a stepped gameplay mechanic rollout that gradually teaches people incredibly complex game mechanics over time.

A simple example to counter the auto-configuration interpretation most of the other commenters are thinking of. In a toolbar dropdown, highlight all the features I already know how to use regularly. When you detect me trying to learn a new feature, help me find it, highlight it in a "currently learning" color, and slowly change the highlight color to "learned" in proportion to my muscle memory.

it is a case of "those who don't know history are doomed to repeat it.

Microsoft already tried this in office when they made the menu order change with usage frequency. People hated it

I've been writing complex scientific UIs for more than two decades and still don't feel like I always get it right. We aim for "gradual reveal" and making the most common options easy to find and use, but it's hard to get that right for everyone.

Microsoft tried hiding less commonly-used menu options a decade or so with Office and it was so terrible they abandoned it - only to try the same approach with the Windows 11 Explorer menu.

I absolutely hate that rigid "Basic" vs. "Advanced" distinction, but one of our image processing UIs was so complicated a customer really pressed us to add that. We tried and tried and couldn't come up with something better, so we settled on an approach that I still feel is suboptimal.

So I welcome seeing what AI/LLMs may be able to contribute to the UI design space, and customizing per user based on their usage seems like an interesting experiment. But at the same time I'm skeptical that AI will really excel in this very human and subjective area.

We’re working on something adjacent to this[0] by making fluid UIs for public (marketing landing content) front ends. AI allows even compiled code to be arbitrarily modified on the fly, and it’s only going to get easier to start with a “base” of content, functionality, and components - and compose the best outcome for a user.

[0] - https://kenobi.ai

I tell people we have inverted control with the latest agent concepts. Instead of deterministic code treating LLMs as functions, we have LLMs determining the flow of the app and the interaction with the user. It is much more organic when it is done right and you can gain access to features you never coded. We have been implementing UI tools/widgets to allow a much more interactive experience and it is amazing to play with that idea. This will obviously be part of the standard toolkit of agentic software a year or two from now. The agent stack is just now forming and UI is a core piece of it.

In theory this seems like a reasonable solution, but in practice, it really is impossible. Is the help documentation going to be generative too? Or can I only ask a chatbot?

Secondly, the concrete example is not generative UI, it’s just generated data getting put into a schema.

I think the hard part of design is that you must consider the trade off between a new user and a power user. Overwhelm against progressive disclosure. It’s an art form in and of itself.

Here's why this is silly:

Most UI's are fundamentally dumbed down, they're only good for repetitive tasks.

If you're doing any task that is non-repetitive enough such that the UI needs to change, what you really need or would like is an "assistant" who you can talk through, get feedback, and do the thing. Up until very recently, that assistant probably had to be human, but probably obviously, people are now working quite a bit on the virtual one.

That's a bad idea. It isn't deterministic. How do you even make documentation for users for your generative UI? It looks different for every single user.

This smells a lot like "Script X" - a 90's era collaboration between IBM and Apple, but for end-users.

Back in the early-mid 90’s Apple Computer and IBM and I seem to remember some other tech nonsense peddlers formed a joint venture (I'm not looking this up, all from memory), with a name something like Talagent, forgettable.

But their product was supposedly this uber-duper new non-language that was going to completely take over software development. Named “Script-X” it starts with each programmer defining the language they want to use, the syntax and whatnot of the language itself, and then they work in blissful joy writing code in the style they prefer to write code.

I cannot believe they actually managed to create a joint venture, mount a huge industry PR campaign, and start selling this utter shite without thinking this pure idiocy through…

No two programmers working on the same project could read one another’s code. The developers spent a large amount of time changing their minds’ on the specifics of the “optimal language they wanted”, which caused previous work to be incompatible to the language and that programmer who chose to change their programming mental model. Not a single project using their Script-X shipped, it was a total and complete failure.

I was at Philips Media while this was taking place, and being a little software language author myself, I watched this playout with dismay these participants could be so short sighted.

Cant wait to use a program that changes constantly

To me that agentic spreadsheet example looks more like some degenerative UI.

Cold take: honestly, just let users learn how to use your software. Put all your options in a consistent location in menus or whatever - it's fine. Yes, it might take them a little bit. No, they won't use every feature. Do make it as easy to learn as possible. Don't alienate the user with UI that changes under their feet.

Is "learning" now a synonym of "friction" in the product and design world? I gather this from many modern thinkpieces. If I am wrong, I would like to see an example of this kind of UI that actually feels both learnable and seamless. Clarity, predictability, learnability, reliability, interoperability, are all sacrificed on this altar.

> The explosive popularity of AI code generation shows users crave more control and flexibility.

I don't see how this follows.

The chart with lines and circles is quite thought-leadershipful. I do not perceive meaning in it, however (lines are jagged/bad, circles are smooth/good?).

could this kind of interface make it harder for users to discover useful features they might not know to ask for?

Plotly just shut off their Chart Studio web app and “replaced” it with a desktop app called Studio. That desktop app requires LLM chat input for every action. It uses this pattern and trying to figure out the magic words to make it do the basic tasks you have been doing with 3 clicks for the last decade is infuriating. Especially when you realize your data was local to your browser tab unless you saved it before and now it is unconditionally uploaded to a remote server with no obvious way to delete the data.

One of the key elements of effective UX is discoverability.

The user needs to able to discover the capabilities and limitations of the system they are using.

For most practical examples I can think of, this approach would complicate that, if not make it nearly impossible.

This is getting panned, probably for good reasons. But, in a similar vein, I really think that generative applications are going to be big in the future. User speaks (or OS predicts) what they want and an app spins up on the fly. I don’t think they’ll wipe out traditional apps, but I could see lots of long tail cases where they meet users needs.

Stuff like this guarantees future dev work. Its the new institutional spreadsheet mess.

Thanks for sharing this.