What Is Generative UI?

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

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.

But AI?

Yes and this is my biggest anxiety of future software and interfaces to come. You won't remember how you got there or did what because there are n permutations of getting there or doing that, except they're vaguely similar but not exactly the same thing. I too want predictable software (including UIs) that stays the same until I want to change/upgrade it myself as a user.

"Your thumbs will learn" is a famous Steve Jobs quote from the 2007 iPhone launch.

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.

Cant wait to use a program that changes constantly

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.

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

I break out blender every six months or so in order to create a model for 3d printing. It needs to be precise and often has threads or other repetitive structures.

Every. Single. Time. I spend at least the first 3 hours relearning how to use all the tools again with Claude reminding me where modifiers are, and which modifier allows what. And which hotkey slices. Etc etc.

Only if the buttons on the iPhone aren't constantly being rearranged by a chatbot. Then they'll never learn.

"Copilot, make me a drawing app."

MS Paint opens.

"No, Copilot! Make me a drawing app with feature X."

Fans turn on. Laptop gets hot. Ten minutes pass as the entire MS Paint codebase is downloaded and recompiled.

Finally, MS Paint opens. There's an extra button in the toolbar. It doesn't work.

Generative UI is incompatible with learning. It means every user sees something different, so you can't watch a tutorial or have a coworker show you what they do or have tech support send you a screenshot.

The solution could be search. It's not a House of Leaves.

> I want it to just work; that kind of design takes effort & there's no way around it

Nothing "just works" for everyone. You are a product of your environment, people say apple interfaces/OSX are intuitive, I found them utterly unusable until I was forced to spend a lot of time to learn them.

Depending on which software you grew up using, you either find it intuitive or don't. If you found someone that has never used technology, no modern UI would be intuitive.

Personally, I hate it when software that I have to use daily is not configurable (and ideally extensible via programming). It's basically designed for the lowest common denominator for some group of users that product/design groups have decided is "intuitive".

> People hate UI redesigns for a reason...

I do agree here, stop changing things for the sake of changing things. When I owned some internal tools, I would go out of my way to not break user workflows. Even minor things, like tab-order, which I think most people don't think about, I'd have browser automation tests to make sure they remained consistent.

> When you detect me trying to learn a new feature, help me find it...

"It looks like you're trying to learn a new feature. Would you like help?"

I miss Clippy.

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.

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.

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.

> how do you enable power users to learn more powerful tools already present in the software?

On-the-job-training, honestly; like we've been doing for decades, restated as:

Employer-mandated required training in ${Product} competence: consisting of a "proper" guided introduction to the advanced and undiscovered features of a product combined with a proficiency examination where the end-user must demonstrate both understanding a feature, and actually using it.

(With the obvious caveat the you'll probably want to cut-off Internet access during the exam part to avoid people delegating their thinking to an LLM again; or mindlessly following someone else's instructions in-general)

My pet example is when ("normal") people are using MS Word when they don't understand how defined-styles work, and instead treat everything in Word as a very literal 1:1 WYSIWYG, so to "make a heading" they'll select a line of text, then manually set the font, size, and alignment (bonus points if they think Underlining text for emphasis is ever appropriate typography (it isn't)), and they probably think there's nothing more to learn. I'll bet that someone like that is never going to explore and understand the Styles system on their own volition (they're here to do a job, not to spontaneously decide to want to learn Word inside out, even on company time).

Separately, there are things like "onboarding popups" you see in web-applications thesedays, where users are prompted to learn about new and underused features, but I feel they're ineffective or user-hostile because those popups only appear when users are trying to use the software for something else, so they'll ignore or dismiss them, never to be seen again.

> By corollary, how do you turn more casual users into power users?

Unfortunately for our purposes, autism isn't transmissible.

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 :-)

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.

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

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.

Ehhhh....

Is an AI driven feed not UI changes? Those are incredibly successful but the buttons change every refresh.

UIs do not need to be static. The key is that there is a coherent pattern to what's changing.

When you look at it through that lens it doesn't seem so exotic.

the whole point of this is that the buttons keep moving so your fingers can't learn. When steve jobs said it, he thought about it first and was talking about something different

There is a trade off with simplicity though - usually it requires being highly opinionated about which software features make the cut. Users or sales teams often want more features, but if you included every one the app would become a mess.

But there is a possible world where you can have both - every 'feature' your users would ever want without overwhelming complexity or steep learning curves, but with the possible downside/cost of reducing consistency.

Thanks for sharing this.

Yeah, additionally imagine supporting something like that: "Yeah, I cannot reproduce your issue because things on my end look different". A nightmare for sure.

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?

> 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.

This has nothing to do with laziness or attention span. 20 years ago you'd have maybe a dozen programs tops to juggle and they were much better designed, because they were made by people who actually use the software instead of some bored designer at FAANG sweatshop who operates on metrics. Now you have 3-5 chat clients, 20 different web UIs for everything on 3 different OSs, all with different shortcuts. And on top of that it CONSTANTLY changes (looking at you Android and material 3).

5 things deserve knowing in-depth: browser (not a specific website, but browser itself), text editor, Spreadsheet application, terminal and whatever else software you use to put a bread on your table.

For any VCs that seriously think I'll invest non-trivial amount of time into learning their unique™ software – you're delusional. Provide shortcuts that resemble browser/vim/emacs/vscode and don't waste yours and my time.

CLI will always be there, don't worry.

> Stuff like this guarantees future dev work.

Don't worry, it'll be done by more LLMs.

I think you are right in the 'current paradigm' of what software is at the moment, where users are using a fixed set of functionality in the way that the developer intended, but there is a new breed of software where the functionality set can't be defined in an exhaustive way.

Take Claude Code - after I've described my requirement it gives me a customised UI that asks me to make choices specific to what I have asked it to build (usually a series of dropdown lists of 3-4 options). How would a static UI do that in a way that was as seamless?

The example used in the article is a bit more specific but fair - if you want to calculate the financial implications of a house purchase in the 'old software paradigm' you probably have to start by learning excel and building a spreadsheet (or using a dodgy online calculator someone else built, which doesn't match your use case). The spreadsheet the average user writes might be a little simplified - are we positive that they included stamp duty and got the compounding interest right? Wouldn't it be great if Excel could just give you a perfectly personalised calculator, with toggle switches, without users needing to learn =P(1+(k/m))^(mn) but while still clearly showing how everything is calculated? Maybe Excel doesn't need to be a tool which is scary - it can be something everyone can use to help make better decisions regardless of skill level.

So yes, if you think of software only doing what it has done in the past, Gen UI does not make sense. If you think of software doing things it has never done before we need to think of new interaction modes (because hopefully we can do something better than just a text chat interface?).

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

Are you talking about non-business customers?

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.

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

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.

And not being able to have any usable bloody documentation!

Terrible article, poorly written by someone obviously fishing for clout

Cute, but your whole premise relies on knowing the right questions to ask, which you don't. We just had an entire decade of good interfaces being ruined by poorly conceived anemic "user stories" we don't need to further destroy our HCI for the next century or so

UIs definitely need to be static as people eventually build muscle memory

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've heard from users they are burnt out on the UI many apps support. Buggy components everywhere across web, mobile, etc. e.g I can confirm that QuickBooks mobile app has so many bugs still in it for example and it's like 1/10th their web app.

I know personally I hit buggy forms and UI way more than I should preventing me from proceeding.

So I think there is an opportunity to instead have n permutations in natural language where the interface is consistent towards how the user inputs, it will just be up to the developers to support some UI for confirmation and structuring more complex input within chat itself. The biggest issue will be become discovery of what you can and cannot do without stationary UIs hinting at capabilities.

Anyways we are in new territory so it will be interesting how this plays out.i like to think of it as on demand UI but curious how others are toying with this paradigm.

We are testing a mostly display only interface for output where the majority of input comes in from chat and chat UI components right now just to see how this would work in practice.

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.

I would argue the opposite - the premise actually accepts that software developers and product owners can't always know how their software will be used by end users.

Besides, HCI will inevitably change because after 30 years of incremental user interface refinement, your average person still struggles to use Excel or Photoshop, but those same users are asking ChatGPT to help them write formulas or asking Gemini to help edit their photos.

I don't accept the premise that the interfaces were ever actually that good - For simple apps users can get around them fine, but for anything moderately complex users have mostly struggled or need training IMO. Blender as an example is an amazing piece of software - but ask any user who has never used it before to draw and render a bird without refering to the documentation (they won't be able to). If we want users to be able to use software like blender without needing to formally train them then we need a totally different approach (which would be great, as I suspect artistic ability and the technical ability to use blender are not necessarily correlated that strongly).

The right questions aren't always known up front. Some of the reasoning for using AI in the first place is to refine a fuzzy idea, so a tool like this can help one to go from fuzzy to concrete, with good guardrails in place to ensure the concrete is truly solid. The in this case, the point is that the components of good user interfaces are already available, and then composed based on user prompts to their exact specifications and frozen for normal usage. Unfreeze and prompt again later to tweak further, etc.

The biggest issue will be that what you're describing will be 100x buggier than any currently existing application. If forms are buggy now, what makes you think that moving the buttons around non-deterministally would improve this?

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.

I totally agree with this, and I'd go even further.

When I'm having trouble with software, I often turn to Google to figure out how to use it. I'm then directed to a YouTube video, help article, or blog post with instructions.

My take is that people are already accustomed to this question-and-answer model. They're just not used to finding it within the application itself.

Yeah, exactly. This is the progressive disclosure.

AI can give you a smart starting point (like a pre-filled formula) instead of making you start from scratch, and then you dig deeper only if you need to. That's what I mean by personalized software.

You get something that actually works right away, and you can tweak it from there. No need to watch YouTube tutorials or read docs just to figure out where to start.

Do you mean users or developers kowning the right questions up front?

Why do you need *external* documentation but for helping people to understand how software works?

These apps will need lots of documentation but instead of having to "search" for the section you need it would be just exposed as you need it.

"How do I do X?"

You do X by filling out this form: [FORM]

I'm not sure the problem here?

I agree this is a real problem.

We will need a new set of tools to help developers with this.

Just like a whole set of web analytics, logging, feedback tools were built when we moved to the web.

Before you could just gather feedback from your employee interactions, or by watching customers in your store.

I don't see this as categorically different, but the tools do not exist today.

ofc!

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.

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.

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.

I'm curious what makes you say this? I feel like I discover how most sufficiently complex apps work by googling, or youtube.

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.

Good wordplay. It's for sure a toy. It's hard to re-implement an entire spreadsheet.

What about it did you not like?

Okay. They all suck. I want a list of websites that are likely to refer to my search query. Google is terrible at understanding my intent and even more terrible at displaying information in such a way as to facilitate my task.

As an example: I was searching for an item to purchase earlier. It's a very particular design; I already know that it's going to send me a bunch of slightly-wrong knockoffs. The first thing I want to see is all of the images that are labeled like my query, as many as possible at once, so that I can pick through them. Instead, it shows me the shopping UI, which fills the screen with pricing and other information for a bunch of things that I'm definitely not going to buy, because they're not what I'm looking for. Old Google would have had the images tab in a predictable place; I'd be on it without even thinking. Now? Yet another frustrating micro-experience with Nu-gle.

I understand the anxiety, but isn't this already the reality with most complex software?

Photoshop has thousands of possible panel arrangements, yet users develop their own workflows.

The question isn't whether permutations exist—it's whether the system helps you find your optimal permutation faster. Do you think the problem is unpredictability itself, or the lack of a predictable meta-pattern for how changes occur?

I'll be honest, I don't remember this.

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?

I don't disagree that simple and repeatable wins—but isn't there a tension between "simple" and "capable"?

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?

The gamelike progressive tutorial idea is interesting. But games have a fixed learning path. Professional tools don't generally have that linearity.

Doesn't that suggest the "curriculum" has to be personalized? And if it's personalized, aren't we back to something generative?

Clippy!

I guess what if you had Claude in the app, and it didn't just tell you what to do, it could even surface ephemeral UI for each task?

This is really what generative UI would enable.

I agree that the basic vs. advanced or persona A vs. persona B distinction is usually too rigid.

What makes you skeptical that AI will excel at this?

Why do we need documentation?

yeah but when you then need to do the same action 4 times in a row, getting claude to provide the correct action all 4 times takes a lot more brainpower on my part than just learning the menus yet again, right?

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.

Interesting. I tried the demo and couldn't get it to work.

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?

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.

> but there is a new breed of software where the functionality set can't be defined in an exhaustive way.

Then fix your bugs so that the functionality set _can_ be defined in an exhaustive way.

It's not bugs that is the barrier here. Maybe functionality is the wrong word as I'm talking about something higher level than individual features, and maybe 'user stories' better represents what I'm getting at...

What I mean is that 'old' software has focussed on giving users lots of tools for users to complete their tasks, and when we talk about UI's we are talking about how to arrange all those tools in a way that is easy for a user to navigate. Users usually have to learn about all the tools that are there, so they know which ones to use (and over time the ones that learn about the existence of all the tools become 'power users').

But 'new' software might be more about completing users tasks for them, and these higher level tasks are the ones that are hard to define because there are so many permutations of what a user might want to do. As the software is helping users more, end-users might not ever need to know about the existence of all of the tools as they are abstracted away.

The AI spreadsheet example in the linked article is interesting, but that occurs within a more specialized and constrained environment than general GUI design. I think of good UI design as involving a lot of human factors understanding combined with 2D spatial reasoning and layout, which I don't think AI is good at. (Today's article about Claude failing to reproduce an HTML layout to match a screen capture is one example of this: https://news.ycombinator.com/item?id=46183294 )

But my pessimism may be unfounded or based on ignorance. At some point AI will probably get better at these things as well, either with better LLMs or by augmenting LLMs with outboard spatial reasoning modules that they can interact with.

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.