The new game of design: from screen to conversational flow
Design stopped being about drawing a fixed screen. The unit of work became the flow: conversational interfaces, agents, and surfaces that assemble themselves on the spot. Generative AI already produces a beautiful screen in seconds, except for the average user of its training data, not for your real user. This lesson opens the track around one thesis: generating fast isn't the problem, generating fast with nobody real inside is.
You open a generative interface AI tool, describe the app you need, "an order dashboard for a small store," and twenty seconds later you get a finished screen: balanced colors, buttons in the right place, everything looking like a professional product. It's tempting to approve it right there and send it to development. Except that screen was born from an "average user" the AI learned by looking at thousands of similar dashboards on the internet, not from the small store owner who's actually going to use yours, with his own way of organizing orders, his vocabulary, his habit of checking everything on his phone in the middle of the counter. The screen is beautiful. Whether it's correct, you still don't know.
The controller asks the assistant to put together a financial dashboard, and in seconds gets a clean dashboard, with a bar chart, red and green indicators, everything looking like a consulting report. Except that layout was born from the "average financial dashboard" the AI has already seen countless times, not from how the company's actual CFO reads numbers, which indicator he looks at first, what he ignores. The dashboard is beautiful. Whether it's useful for a real decision, you still don't know.
The firm asks AI to generate a case-lookup interface, and gets an organized screen, with filters, search, everything. Except the flow AI put together is the "generic legal flow" from the internet, not the way the firm's senior lawyer actually searches for a case in a rush, in the middle of a hearing. The screen looks ready. Whether it serves real day-to-day use, you still don't know.
The team asks AI to generate a landing page, and gets a page with a beautiful hero, social proof in the right place, an eye-catching CTA. Except that pattern is the "landing page pattern" the AI learned by looking at thousands of similar pages, not what makes that specific brand's customer click. The page converts to the eye. Whether it converts in practice, you still don't know.
The HR team asks AI to generate an onboarding screen, and gets a step-by-step flow, beautiful, with a progress bar and a friendly illustration. Except that flow is the "standard onboarding" the AI has already seen hundreds of times, not how that company's new hire, with that specific culture, actually learns the house rules. The flow looks welcoming. Whether it welcomes for real, you still don't know.
The PM asks AI to generate the MVP screens from the PRD, and gets a clickable prototype in minutes, with a full flow from sign-up to checkout. Except that flow was born from the "average product" in the category, not from the two objections the real target customer raises before buying. The prototype looks ready for the board. Whether it solves the customer's real objection, you still don't know.
The sales team asks AI to put together a proposal interface, and gets a clean visual document, with an ROI chart and a guarantee section. Except that template is the "proposal template" AI learned by seeing thousands of examples, not the specific argument that closes that client, in that sector, with that price objection. The proposal looks professional. Whether it closes the deal, you still don't know.
The operations team asks AI to generate an SLA dashboard screen, and gets a dashboard with traffic lights, trend charts, everything aligned. Except that design is the "standard operational dashboard," not the way the night shift supervisor, phone in hand on the factory floor, actually needs to spot the bottleneck in three seconds. The dashboard looks complete. Whether it serves the real shift, you still don't know.
The compliance team asks AI to generate an evidence-logging interface, and gets an organized screen, with a field for each control and a color-coded status. Except that layout is the "generic audit form" from the internet, not how that specific company's auditor, under that specific regulation, needs to navigate under deadline pressure. The screen looks compliant. Whether it passes a real audit, you still don't know.
The engineering team asks AI to generate the admin interface for the new system, and gets a full dashboard in minutes, with a table, filters, and bulk actions. Except that design reflects the "generic admin" every UI generator produces, not how that company's support team actually resolves the urgent ticket. The dashboard looks functional. Whether it solves the real use case of whoever operates it, you still don't know.
You open a generative AI tool (like v0, Figma AI, UX Pilot) to generate the onboarding screen for a new app, describe the goal in two sentences, and twenty seconds later you get a whole flow: welcome screen, three setup steps, progress bar, friendly microcopy. Flawless to the eye: correct visual hierarchy, consistent spacing, even follows basic accessibility best practices. You almost approve it to send straight to development. Except that flow was born from the "average onboarding user" the model learned by seeing thousands of similar apps, not your real user, the one who abandons on the second step because the app asks for location permission before showing any value, a pattern that only shows up in your own product's Hotjar session recordings, not in anyone's training data. The screen is ready. Whether it's right for your user, AI doesn't know that, and you only find out by asking.
The board asks AI to put together a goal-tracking interface, and gets an elegant dashboard, with progress indicators and visual alerts. Except that design reflects the "average executive dashboard" from the internet, not how that specific board weighs risk versus opportunity. The dashboard impresses in the meeting. Whether it guides the right decision, you still don't know.
Whoa, let me tell you about the shift that's already changed the ground under your feet in design, even if nobody spelled it out for you yet. For decades, the work of design was the screen. You'd draw a wireframe, refine a mockup, deliver a static prototype, pixel perfect, and the developer would build exactly that. The unit of delivery was the screen, and you were judged by the screen. Except the unit became something else. Today a big chunk of interaction no longer goes through any fixed screen at all: it's a conversation with an agent, it's voice, it's a surface that assembles itself on the spot, different for each person, depending on what they asked for. And to complete the shift, a tool showed up that generates that old, familiar screen in seconds, except with nobody real inside it. This is the lesson that frames the whole track on top of this double shift.
The core idea of this lesson. Design went through two changes at the same time, and they're happening together. First, the unit of work stopped being the fixed screen and became the flow: conversational interfaces, agents, voice, generative surfaces that assemble themselves on the spot, differently with every interaction. Second, generative interface AI itself (v0, Galileo AI, UX Pilot, Figma AI, Lovable, and whatever comes next) already delivers a finished, beautiful screen, with generic best practices baked in, in minutes. The risk that gives this lesson its name is precisely that: AI generates for the average user of its training, not for your real user, and an interface can look ready without ever having been checked against real data. The thesis that guides this whole track, and I want it stuck in your head: generating fast isn't the problem. Generating fast with nobody real inside is the problem. You're going to learn to architect the flow with the real user inside, not just the pretty screen on the outside.
01From the fixed screen to the flow that shapes itself on the spot
Let's call it what it is. You learned design thinking in screens: a sequence of fixed screens, each with its own state, connected by predictable navigation. The user would click, the next screen would appear, always the same for everyone. That model still exists, but it stopped being the center of the game. Today a huge slice of interaction happens inside a chat, inside an agent that answers by voice, inside a surface that appears only when it makes sense and disappears when it doesn't anymore. There's no fixed screen to draw because the screen's content changes with every question, every user, every context.
Think about the size of the change for someone who lives inside a Figma file. You're no longer drawing a sequence of states that repeats identically for everyone. You're drawing a behavior: what the system does when the user asks for X, what it asks back when information is missing, when it shows a real screen and when it resolves everything in a text response. It's the difference between drawing a house and drawing the rules for how the house assembles itself, depending on who walks in.
02The catch: AI already generates the beautiful screen, for the wrong user
Here comes the second shift, and it's the one that gives this lesson its name. Right when design needed to learn to draw flow, a generation of tools showed up that solves the old problem all by itself: v0, Galileo AI, UX Pilot, Figma AI, Lovable and the like generate a whole screen, with correct visual hierarchy, consistent spacing, even basic accessibility baked in, from a single prompt. In seconds. It's fast, it's beautiful, and it's too seductive not to trust with your eyes closed.
Except there's a catch, and it's the catch that separates whoever uses this generation right from whoever fools themselves. This AI learned by looking at thousands of similar interfaces, and what it returns is the statistical average of what tends to work in general. It has never seen your user. It doesn't know that, in your base, it's exactly the location-permission request right on screen 2 that makes one in three users close the app, a pattern that only exists in your own company's Hotjar session recordings, not in any model's training data. The screen it generated looks ready because it follows the general rules of good design. Whether it's right for your case is a different question, and it's a question only real data answers.
03The track's thesis: nobody real inside is the problem, not the speed
Now the part that organizes the rest of the course. Faced with this risk, it's tempting to conclude that the solution is to distrust fast generation and go back to drawing everything from scratch, screen by screen, the old way. That would throw away the real, honest gain these tools bring, and it's huge: what used to take days of wireframing now takes minutes, freeing up your time to do the work only a human can do, which is validating against real people.
This track's thesis is the middle path, and it's the only one that holds up: generating fast isn't the problem. Generating fast with nobody real inside is the problem. You don't give up speed. You make sure that, before approving any generated screen or flow, there's someone real inside the decision: a research data point that confirms it, a recorded session that validates it, a synthetic user calibrated with real data that tests it before the real human does. It's the same spirit as lesson 1.1 of this course, just applied to your craft: there the difference was between an AI that talks (returns text for you to carry over) and one that acts (works on your material and shows it to you to check). Here the difference is between an AI that draws pretty (returns a generic screen ready to approve in the dark) and one that draws right (works anchored in your real user and shows you the evidence before you approve).
04The map of this track
This lesson was the framing. The module's name already delivers the promise: Business in UX and Design in an era when the machine draws fast, but only you make sure it draws right. The rest of the track is hands-on, installing this into your real routine, one system at a time:
- Connecting AI to real, live research (Dovetail, Hotjar, support tickets), so it stops guessing and starts reading your user.
- Turning loose interviews into a pattern with traceable citations, without losing track of who said what.
- Testing the flow with a synthetic user before the real human, never instead of them.
- Keeping the design system alive, with components, tokens, and documentation that don't rot.
- Auditing accessibility for real, with agent and with people.
- Auditing the insight itself, to catch the moment when synthesis invents a pain point nobody actually mentioned.
- And, in the end, your design operating system: the dashboard, the prompts, and the routine that guarantee every generated screen has someone real inside it.
Each lesson takes a piece of your design process and reconnects it to real data, so you keep gaining speed without losing your footing. By the end, you won't have learned to use a generative AI tool. You'll have rebuilt your design process to become someone who architects the flow with the user inside, not just someone who approves the pretty screen the machine handed over. Let's go?
Do it now
Today's exercise is quick and will give you exactly the healthy scare you need. Grab a generative interface AI tool you have on hand (v0, Figma AI, Lovable, UX Pilot, doesn't matter) and generate a screen for a real flow in your product, the fast way as usual: one prompt sentence, approve the result at a glance.
Now stop and answer, hand on your heart:
- WHAT USER DOES THIS SCREEN IMAGINE? Describe in one sentence who the AI seems to have had in mind when generating that layout, that hierarchy, that button copy.
- WHAT REAL DATA DO YOU HAVE about your user that confirms or contradicts that assumption? A session recording, a ticket, an interview, a review.
- IF YOU DON'T HAVE THAT DATA ON HAND right now, write this down as the first real gap in your UX track: it's exactly the hole the next lesson closes.
Keep this screen and these three answers. They're your starting point for the track, the before of any live-research system you're going to build from here on.
Practice
1. What is the central risk this lesson names about using generative interface AI (v0, Figma AI, UX Pilot and the like)?
2. What is the thesis that guides the whole Business in UX and Design track, according to this lesson?
3. How does the difference between 'AI that talks' and 'AI that acts' (lesson 1.1) apply to interface design, according to this lesson?
4. When generating a new screen with generative interface AI, which practice, according to this lesson, avoids the risk of a 'beautiful interface that ignores the real user'?
Fair? Let's close the message of this opening together. Design didn't die or become obsolete, it changed units: from the fixed screen to the flow that shapes itself with every interaction, and it gained a new, powerful tool that generates that screen in seconds. The risk isn't in the speed, it's in approving in the dark a screen made for the average user of the training, without checking whether it serves your real user. The thesis that guides this whole track, for you to pin on the wall: generating fast isn't the problem, generating fast with nobody real inside is. You're going to learn, lesson by lesson, to keep someone real inside every screen you approve, without losing a single second of the speed you gained. Next.
For the board
On the unitthe deliverable stopped being the fixed screen and became the flow that shapes itself on the spot.
On the riskthe AI already generates the beautiful screen for the wrong user. Beautiful to the eye because it follows the general pattern.
On the thesisthe problem is not the speed, it is having nobody real inside the decision.
Thanks for the feedback. It helps sharpen the next lesson.