The shopping list I didn't download
Last weekend I needed a shopping list app. The brief was one line: I talk, it writes the list.
What I had in mind was a walk around the kitchen. Open a cupboard, open the fridge, and call out whatever's running low as I spot it. Olive oil. Rice. Eggs. That spice I only use once a month and I'm always out of. It's random and out of order, and my hands are full. Typing into an app doesn't fit that moment. Talking does.
I opened the App Store and saw the usual: subscriptions, ads, onboarding flows, features I'd never touch. So I described what I wanted to Claude instead, and it built me a voice-dictation shopping list as an artifact. It did one job, exactly the way I wanted it done.
That small moment has stuck with me. Building the tool was easier than finding one. For twenty years I've helped teams decide which screens to build, in what order, for which users. What happens to that work when a screen can be made on the spot, for one person, for one afternoon?
This is already shipping
The name for this is generative UI: an interface an AI model builds at the moment it's needed, shaped to the person and the task. A few years ago it was a concept piece. Now it's in products.
A few examples make it clearer. In each one, nobody designed that exact screen in advance. The model put it together from the request, the data it could reach and a set of approved parts.
- Planning a trip. You ask an assistant for three days in Tokyo with kids. Instead of paragraphs, you get a day-by-day itinerary with a map, times and a toggle for rainy-day options.
- Checking your spending. You ask your banking app where your money went this month. It builds a chart grouped the way you asked, with your three biggest surprises called out, then a button to set a limit.
- Getting support. You tell a support assistant your delivery arrived damaged. It shows a short form with only the fields that matter for that problem: order, photo upload and refund or replacement.
- Booking a flight. NN/g's example is an airline that shapes the booking flow to each traveller, from their past trips and preferences, rather than one flow for every flyer.
- Following up at work. Atlassian uses A2UI so its Jira agent can reply with an interactive card you can act on, instead of a block of text.
- A tool for one. My shopping list: a single-purpose app made for one person, one job, one afternoon.
Meanwhile, the pieces needed to build this at scale are arriving:
- Google put generative UI into the Gemini app and Search's AI Mode about a year ago. In its testing, people preferred the generated interfaces to standard search results and plain-text answers. Sites built by human experts still came out on top. Google also admits generation can take a minute or more, and that outputs sometimes contain errors.
- A2UI, Google's open standard for agent-generated interfaces, reached version 1.0 last week. Atlassian, Bloomberg and ByteDance are named as building with it.
- MCP Apps let a tool show its own interactive interface inside AI assistants such as Claude, ChatGPT and Gemini.
- Personal software is everywhere. Developer Francis Irving wrote in August about vibe coding his own apps for places, people and music, on an £18-a-month plan.
The big companies are moving too. Thomas Vidal, VP Product Design at Accor, wrote this week that they're moving from designing interfaces to designing the systems that generate experiences. They're exploring a new role, the Generative Experience Designer, with an operating model that brings design, product and tech closer together. It's someone who shapes how models behave, how data and context are orchestrated, and how personalised experiences are generated at scale. He lists golden datasets (real requests paired with what a good answer looks like), AI-ready design systems, tone of voice, evaluation and guardrails as the foundations. That list reads like a job description for the next few years of product design.
When the screen is cheap, what's worth building?
Worth Building keeps coming back to one question: what's worth building, now that building is cheap? Generative UI pushes it a step further. If the interface can be made in the moment, the screen stops being the expensive part of a product.
So where does the value sit? I think it moves to three places.
- The data and context. My shopping list worked because it only needed my voice and a list. A dashboard generated from a prompt is only as good as the data it can reach and how well it understands what I'm asking. Access to the right context is the product.
- The building blocks. Google's A2UI standard is clear on this. Agents can only place components you've registered from your own design system. The model assembles the screen, but it uses your parts.
- The judgement about what stays fixed. NN/g described designers becoming "designers of parameters and constraints". They mean deciding what must show, what can show and what never shows. Some flows should never be improvised: payments, consent, anything with legal or safety weight. Deciding that line is a product decision before it's a design one.
The interface will follow the flow of what someone is trying to do. Fewer hard-coded step-by-step journeys, more screens shaped to the person, their context and the need at that point in time. The product becomes something closer to organic, grown from fixed rules and good parts.
Where the work moves for product and design
Neither product nor design shrinks here. Both move upstream, into the rules the model works within. Here's how I see the shift, from building fixed screens to building generated experiences:
- Mock up each screen and state becomes define the components and the rules for combining them.
- Write the copy for each screen becomes define a tone of voice the model can follow.
- Design for the average user becomes design for the individual, in context.
- Usability test a flow becomes evaluate many generated outputs against a standard.
- Spec edge cases by hand becomes set guardrails and decide what is never generated.
- Hand off to engineering becomes work with engineering on data, context and evaluation.
- Write requirements for each feature becomes define the outcome, the success signal and what the model is allowed to decide.
- Prioritise a roadmap of screens becomes prioritise the data, context and capabilities the model can draw on.
- Measure which screens get used becomes measure whether the task got done, and how often the output was right.
Builder.io put it well: AI is "a chaotic user of your design system". Most design systems were written for people who read the docs and ask when they're unsure. A model does neither. Rules like "only show a chart when comparing more than three data streams over time" need to be written down where a machine can read them.
This is also why I think the line between product and design keeps blurring. The questions that matter most here are product questions. What outcome are we designing for? What data do we trust? Where is the risk? Who checks the output?
The catch: people still need to trust it
When I wrote about my title saying design while I did product work, one comment stuck: AI pilots are cheap, and operational adoption is hard. Generative UI has the same problem, with a few extra edges.
- Consistency. People learn where things are. NN/g warned early that interfaces that keep changing create usability problems. A generated screen that moves the button every visit is a regression, however personal it looks.
- The unhappy path. Generated UI is good at the happy path and weak on loading, error and empty states. Those states are where trust is won or lost.
- Ownership. Francis Irving loves his personal apps, but says he doesn't fully feel he owns them. One of his features deleted a whole list on his phone. That's fine for a weekend tool. It's not fine for a customer's invoices.
- Speed and accuracy. Even Google says its version can take a minute or more and sometimes gets things wrong.
None of these kill the idea. They're the work. A shopping list can be disposable. A product people rely on every day needs fixed foundations, clear rules and someone accountable for the output. That's what design and product teams are for.
Where to start, whatever your title
You don't need a generative product to get ready for one. Five things a product manager and a designer can do together this month:
- Map one flow. Take a journey you own and mark each step: must stay fixed, could be generated, or should never be generated.
- Write three rules for a machine. Pick three things your design system assumes a human will just know, and write them down so a model could follow them.
- Start a golden dataset. Collect 20 real customer requests and write what a good response would look like for each.
- Check your context. List the data a model would need to serve that flow well, and whether you can actually reach it today.
- Redefine success. If every customer saw a different screen, how would you know it worked? Write that measure down before anyone builds anything.
So what's worth building?
The hard-coded app has plenty of life left. But I think the products that feel alive over the next few years will be the ones that bend to fit the person using them. They'll be built by teams that understand the context and the need, and have done the unglamorous work: good data, a design system written for machines as well as people, a clear tone of voice, and firm lines on what's never generated.
The screen gets cheaper every month. The judgement about what goes on it doesn't.
I'd love to hear from you:
- Have you built a small tool for yourself instead of downloading one? What was it?
- If your product generated its own screens tomorrow, what's the one flow you'd never let it touch?
- Is your design system ready for a user that never reads the docs?
- If every customer saw a different screen, how would you measure whether your product worked?
Sources
- Generative UI and Outcome-Oriented Design, Kate Moran and Sarah Gibbons, NN/g, March 2024
- Generative UI: a rich, custom, visual interactive user experience for any prompt, Google Research, November 2025
- A2UI 1.0, Google Developers Blog, November 2026
- MCP Apps vs A2UI, sunpeak, October 2026
- Designing Generative UI in an Agent-Native World, Alice Moore, Builder.io, May 2026
- Vibe coding personal apps in mid-2026, Francis Irving, August 2026
- When Generated UI Actually Works, Stuti Mazumdar, Think Design, February 2026
- Thomas Vidal on the Generative Experience Designer role, LinkedIn, November 2026
Written by Justin Roberts with AI as a research and editing partner. The experiences and opinions are mine.