I'm suggesting you don't generally need menus. The pattern is closer to search like Apple Spotlight or Chrome New Tab... I think most people do that now instead of bookmarks or clicking through menus? Am I wrong?
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?).
> 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.
Consider Google's search results page (setting aside the ads and dark patterns for a moment) as a form of generative UI.
You enter a term, and depending on what you entered, you get a very different UI.
"best sled for toddler" -> search modifiers (wood, under $20, toboggan, etc.), search options, pictures of sleds for sale from different retailers, related products, and reviews.
"what's a toboggan" -> AI overview, Wikipedia summary, People Also Ask section, and a block of short videos on toboggans.
"directions to mt. trashmore" -> customized map of my current location to Mt. Trashmore (my local sledding hill)
Google has spent an immense amount of time and effort identifying the underlying intent behind all kinds of different searches and shows very different "UI" for each in a way makes a very fluid kind of sense to users.
I think the problem is having to "learn" software in the first place. You don't have to "learn" how to work with a good accountant or lawyer. They make it easy by exposing what they can offer precisely when you need it.
That's how I think software will work in the future. I'm not suggesting that the UI should be completely different on every render. Some predictability is essential. That's one reason I don't think codegen on every render is worthwhile. I'm simply suggesting that software should look different from user to user based on their individual needs.
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.
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.
Yes, and that's the point. In my opinion, this is the perfect use case for generative AI, one that takes advantage of the strengths of the technology while avoiding its weaknesses.
The generative UI example in the article is an example of the complete opposite of this idea - obtuse implementation of generative AI where it creates more problems than solutions. Yes, there is value in the idea of personalized UI. But UI/UX derives a lot of its value from consistency, as the other comments in this thread have mentioned. Losing that in exchange for personalization is a huge net negative, in my opinion.
Good question. When I think about how people actually discover features, it's usually:
1) clicking through menus
2) reading docs/watching tutorials
3) getting hands-on help from a coworker or support person
Some apps try to do progressive disclosure as you get better at using them, but that's really hard to scale. Works okay for simpler apps but breaks down as complexity grows.
With generative UI, I think you're basically building option 3 directly into the app.
Users learn to just ask the app how to do something or describe their problem, and it surfaces the right tools or configures things for them.
Still early days though. I think users will also have to adopt new behaviors to get the most out of generative apps.
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.
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.
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.
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.
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.
Forcing chat for every action when direct UI interactions worked fine is definitely not what I'm advocating.
I'm arguing for isn't chat-only interfaces. It's giving users both options: use the UI directly for quick changes you already know how to make, chat when you don't know where to find something or you have a complex multi-step task.
Different users will prefer different methods for different tasks. The goal is software that works how the user wants it to work, not just optimized for one interaction style.
Remote LLMs is a real constraint right now.
I'm hoping for a class of generative apps that can be run entirely locally. I believe it will exist, just not right now.
A teacher that needs to know the kids that are struggling the most with a recent exam doesn't want to ask the AI 10 different ways, deal with hallucinations and frustrations, send tech support a ticket only to receive a response that the MCP doesn't support that yet - isn't going to be impressed.
They just want to see a menu of available reports, and if the one they want isn't there, move on to a different way of doing what they need.
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.
These apps will likely require extensive documentation.
The question is: Why expose it to the user if you can use an LLM to surface only the relevant information, contextualized to what they are doing?
We use this in our app, and it reads our docs to provide context when rendering the UI. I hope that most users never actually read our docs, and eventually learn to ask our app.
It can generally show the right UI, help them configure it, and use docs to ground it.
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?
B2B is a lot more rewarding in this sense. When you've found your power-user any piece of feedback is useful. If it's good enough for them, then the rest typically follows.
This also keeps my motivation when developing UI, because I know someone else cares.
Businesses forgot about this and I ended up a job where I just do whatever my PM says.
I sometimes have this argument with my Product Owner, despite believing we both want what we individually believe is best for our users. I've tried to suggest that the ideal interface for a power user is not the ideal interface for a novice, and that none of our users should be novices for long as an expectation.
I work on an internal app for an insurance company that allows viewing and editing insurance product configuration data. Stuff like what coverages we offer, what limits and deductibles apply to those, etc. We have built out a very very detailed data model to spell out the insurance contract fully. It has over 20 distinct top-level components comprising an "insurance product". The data generated is then used to populate quoting apps with applicable selections, tie claims to coverage selections, and more.
Ultimately these individual components have a JSON representation, and the "power user" editor within our app is just a guided JSON editor providing intellisense and validation. For less technical users, we have a "visual editor" that is almost fully generated from our schema. I thought perhaps this article referred to something like that. Since our initial release, a handful of new top-level components have been added to the schema to further define the insurance product details. For the most part, these have not required any additionally coding to have a good experience in our "visual editor". The components for our visual editor are more aligned to data types: displaying numbers, enums, arrays, arrays of arrays, etc, which any new schema objects are likely to be built from. That also applies to nested objects i.e. limits are built from primitives, coverages are built from limits. Given user feedback we can make minor changes to the display, but it's been very convenient for us to have it dynamically rendered based of the schema itself.
The schema is also versioned and our approach ensures that the data can be viewed and edited regardless of schema version. When a user checks out a coverage to edit it, the associated schema version is retrieved, the subschema for coverages is retrieved, and a schema parser maps properties of the schema to the appropriate React editor components.
p.s. These patterns might be commonplace and I'm just ignorant to it. I'm a backend dev who joined a new team that was advertised as a backend gig, but quickly learned that the primary focus would be a React Typescript app, neither of which I had any professional experience with.
> The case against complex UI hides the fact that nobody wants to take their time to learn a piece of software anymore.
Just look at the shitshow Google or Microsoft UIs are. Every couple of months, somebody decides that UI elements must change shape or place or must be hidden based on "context" or behind hamburger menus.
Nobody wants to continously learn and relearn the same interface (hello ribon)
Tell that to Google, which decided that Messages must be like iMessage and made a "multipurpose" button from the "send" button. For now.
<s>
I think now they are working on exploit compatibility, because they forgot to update the UI (or was I so lazy to update the app for "bug fixes and compatibility improvements ?) /s
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.
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.
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.
UI has really gotten down in the last couple of years.
Reduced information density
Abuse of paradigms we learned in the past (e.g. blue button to accept, links for decline) to make us accept harmful settings
Notifications for just about everything
Popups inside of the app
Adding buttons for functionality that's not included in your subscription, which show the nagscreen once you click on it
UI upgrades which add nothing (see all above)
Removal of agency. I don't want the upgrade, nor do I want to be reminded in 3 days.
A changing UI sounds absolute hell to me. When I was growing up I broke my Windows installation a lot by changing settings. That's how I learned.
41 comments
[ 2.5 ms ] story [ 68.4 ms ] threadMicrosoft already tried this in office when they made the menu order change with usage frequency. People hated it
I'm suggesting you don't generally need menus. The pattern is closer to search like Apple Spotlight or Chrome New Tab... I think most people do that now instead of bookmarks or clicking through menus? Am I wrong?
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?).
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.
You enter a term, and depending on what you entered, you get a very different UI.
"best sled for toddler" -> search modifiers (wood, under $20, toboggan, etc.), search options, pictures of sleds for sale from different retailers, related products, and reviews.
"what's a toboggan" -> AI overview, Wikipedia summary, People Also Ask section, and a block of short videos on toboggans.
"directions to mt. trashmore" -> customized map of my current location to Mt. Trashmore (my local sledding hill)
Google has spent an immense amount of time and effort identifying the underlying intent behind all kinds of different searches and shows very different "UI" for each in a way makes a very fluid kind of sense to users.
That's how I think software will work in the future. I'm not suggesting that the UI should be completely different on every render. Some predictability is essential. That's one reason I don't think codegen on every render is worthwhile. I'm simply suggesting that software should look different from user to user based on their individual needs.
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.
Doesn't that suggest the "curriculum" has to be personalized? And if it's personalized, aren't we back to something generative?
The generative UI example in the article is an example of the complete opposite of this idea - obtuse implementation of generative AI where it creates more problems than solutions. Yes, there is value in the idea of personalized UI. But UI/UX derives a lot of its value from consistency, as the other comments in this thread have mentioned. Losing that in exchange for personalization is a huge net negative, in my opinion.
1) clicking through menus 2) reading docs/watching tutorials 3) getting hands-on help from a coworker or support person
Some apps try to do progressive disclosure as you get better at using them, but that's really hard to scale. Works okay for simpler apps but breaks down as complexity grows.
With generative UI, I think you're basically building option 3 directly into the app.
Users learn to just ask the app how to do something or describe their problem, and it surfaces the right tools or configures things for them.
Still early days though. I think users will also have to adopt new behaviors to get the most out of generative apps.
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.
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 :-)
Excel is neither simple nor explicit, yet it's the most successful end-user programming tool ever made.
Could generative UI be a path to creating powerful tools feel simple by hiding complexity until needed, rather than dumbing down the tool itself?
I'm arguing for isn't chat-only interfaces. It's giving users both options: use the UI directly for quick changes you already know how to make, chat when you don't know where to find something or you have a complex multi-step task.
Different users will prefer different methods for different tasks. The goal is software that works how the user wants it to work, not just optimized for one interaction style.
Remote LLMs is a real constraint right now.
I'm hoping for a class of generative apps that can be run entirely locally. I believe it will exist, just not right now.
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.
I'm also not convinced this makes traditional methods: walkthroughs, support videos, trainings etc impossible?
My friend just discovered coding agents (lol), and he's constantly finding new things it can do for him...
"Oh it can ssh into my raspberrypi and run the code to test it. Wow"
That was an emergent property of the cli coding agent that had no "traditional" discoverability.
They just want to see a menu of available reports, and if the one they want isn't there, move on to a different way of doing what they need.
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.
The question is: Why expose it to the user if you can use an LLM to surface only the relevant information, contextualized to what they are doing?
We use this in our app, and it reads our docs to provide context when rendering the UI. I hope that most users never actually read our docs, and eventually learn to ask our app.
It can generally show the right UI, help them configure it, and use docs to ground it.
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?
B2B is a lot more rewarding in this sense. When you've found your power-user any piece of feedback is useful. If it's good enough for them, then the rest typically follows.
This also keeps my motivation when developing UI, because I know someone else cares.
Businesses forgot about this and I ended up a job where I just do whatever my PM says.
I work on an internal app for an insurance company that allows viewing and editing insurance product configuration data. Stuff like what coverages we offer, what limits and deductibles apply to those, etc. We have built out a very very detailed data model to spell out the insurance contract fully. It has over 20 distinct top-level components comprising an "insurance product". The data generated is then used to populate quoting apps with applicable selections, tie claims to coverage selections, and more.
Ultimately these individual components have a JSON representation, and the "power user" editor within our app is just a guided JSON editor providing intellisense and validation. For less technical users, we have a "visual editor" that is almost fully generated from our schema. I thought perhaps this article referred to something like that. Since our initial release, a handful of new top-level components have been added to the schema to further define the insurance product details. For the most part, these have not required any additionally coding to have a good experience in our "visual editor". The components for our visual editor are more aligned to data types: displaying numbers, enums, arrays, arrays of arrays, etc, which any new schema objects are likely to be built from. That also applies to nested objects i.e. limits are built from primitives, coverages are built from limits. Given user feedback we can make minor changes to the display, but it's been very convenient for us to have it dynamically rendered based of the schema itself.
The schema is also versioned and our approach ensures that the data can be viewed and edited regardless of schema version. When a user checks out a coverage to edit it, the associated schema version is retrieved, the subschema for coverages is retrieved, and a schema parser maps properties of the schema to the appropriate React editor components.
p.s. These patterns might be commonplace and I'm just ignorant to it. I'm a backend dev who joined a new team that was advertised as a backend gig, but quickly learned that the primary focus would be a React Typescript app, neither of which I had any professional experience with.
Just look at the shitshow Google or Microsoft UIs are. Every couple of months, somebody decides that UI elements must change shape or place or must be hidden based on "context" or behind hamburger menus.
Nobody wants to continously learn and relearn the same interface (hello ribon)
Tell that to Google, which decided that Messages must be like iMessage and made a "multipurpose" button from the "send" button. For now.
<s> I think now they are working on exploit compatibility, because they forgot to update the UI (or was I so lazy to update the app for "bug fixes and compatibility improvements ?) /s
[0] - https://kenobi.ai
What are you using to modify the site for each person?
I can see how you personalize software with use, but how do you personalize a landing page before you have any user context?
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.
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.