15 classic UX problems you can now just solve

We can use LLMs to build vastly better products. And NO, not as the chat widget, the sparkle icon, or some mystic design workflow (looking at you, Figma MCP (even more looking at you designers who are tool-and-process-obsessed forgot to care about real solutions (But I disgress))).

What I mean is the good old UX problems we used to give up on, because the fix needed data we didn't have, or data too messy to use. We'd love to show a user some custom UI based on what they do, but we just can't. I ran into this a lot in my own work: we could've vastly improved the product with some personalisation, but it just wasn't possible, or too hard to implement.

But hey, we have AI now. An LLM can infer new data from what you already have, or turn your messy data into structure you can actually work with.

So here are fifteen of those old problems, solved. (And the longer story behind it.)

1. One-sentence signup

Role, company size, use case and team size, all asked before the user has seen a single screen, because once the signup form is gone, the chance to collect that data is gone too. Instead, let people type one sentence about what they're here for (or skip even that) and extract the structured fields from it. The email domain and their first actions in the app fill in the rest.

2. Custom product tours

Tours explain the UI to everyone in the same order, so everyone clicks them away. With usage data and an LLM, you can nudge one feature at the right moment, with the user's own behavior as the argument: "You create about ten items every week, one by one. There's a bulk add." A tooltip that knows what you're doing is a lot harder to dismiss.

3. Personalized starter content

A new account greets you with an empty screen and a sad illustration. Starter content used to be generic ("My first project") because nobody could author it for every single use case. Now sample data can match what the user said during signup, so the first screen looks half-started instead of dead.

4. Profiles that fill themselves

Apps beg for filled profiles and users don't fill them. But users tell you who they are all the time, in their freeform inputs and in how they behave, and an LLM can turn that into structured profile data while they just use the product. I wrote up a full example with code and prompts: AI-powered user onboarding.

5. Automatic naming

Naming things is manual work, so it doesn't happen, and then nothing is findable. A title can be derived from the content the moment something is saved. Linear suggests issue titles this way, and nobody thinks of it as an AI feature.

6. Automatic tagging

The same story as naming: tags and categories are essential for finding things later, and nobody sets them. An LLM can sort new content into your existing structure as it comes in. Notion's database autofill does this, suggesting values straight from the tags you already use.

7. Zero results with a way out

"No results found" is where shopping carts go to die. Semantic search understands that the user's "couch" is your "sofa", and when there really is nothing, an LLM can explain why and offer the nearest thing instead of a wall.

8. Freeform input instead of dropdowns

Long select menus exist because the system needs one of 40 valid values and couldn't trust typed input. Now it can: let the user type whatever they want, map it to the right option, and keep the list around as a fallback.

9. Forgiving input parsing

Someone types "next Tuesday at 3" or pastes a whole list straight out of Excel, and we answer with a validation error. An LLM parses messy human input into clean fields, so "be liberal in what you accept" finally works for real.

10. Helpful error messages

"Error 422: validation failed" was never the best we could do, just the cheapest, because someone had to hand-write a better message for every case. A generated message can say what's wrong with this specific input and how to fix it.

11. Catch-up summaries

Nobody reads the 200 messages that piled up since their last visit. The data was always there, but compressing it into three useful sentences for each individual user wasn't possible. A quiet "what changed while you were away" fixes a real overload problem.

12. Notification triage

Everything gets sent, because deciding what matters to each user was impossible. An LLM can score relevance in context, hold back the noise, bundle the rest into a digest, and still let the one urgent thing through.

13. Personal win-back emails

Re-engagement blasts ignore why the user left, because the per-user reason was unknowable. It sits in their behavior, their drop-off point, even the tone of their last support ticket, and a win-back message can finally reference what the user actually did and what they'd come back to.

14. Inferred preferences

We ask users to configure their interests because we couldn't infer them, and they simply never do. Preferences can be derived from behavior and confirmed in passing, instead of collected through a settings page nobody opens.

15. Generated alt text

More than half the web ships images without descriptions, because alt text is manual housekeeping. It can be generated from the image, in context and in the user's language, even for user-generated content where no editor ever existed.

To be continued

Right now, I think this collapses into some principles, work in progress:

1. Turn unstructured input into structured data (1, 4, 9)
2. Turn data into words a human wants to read (10, 11, 13)
3. Read meaning from sparse signals (2, 12, 14)
4. Classify and match things to their name, tag, duplicate or result (5, 6, 7, 8)
5. Generate content that knows the user (3, 15)

Once you know these, I bet you'll spot a candidate or two in your own product within minutes.

I want this list to grow. If you've shipped one of these, or you're staring at a problem that belongs here, write me: hello@tomreinert.de