DEV Community: Katerina Bulkina

The Real Cost of Generating UI Without a Designer

Katerina Bulkina — Mon, 29 Jun 2026 07:40:00 +0000

Every Monday morning, I spend a couple of hours going through what founders built over the weekend with Lovable or v0. They often send over screens that indeed look impressive, but at first glance. Then I start clicking around, and this is when the illusion breaks.

AI design tools work well for what they do. But the problem I keep seeing is that some founders frequently confuse screen rendering with product design. These two are completely different activities, and there’s a high probability that mixing them can cost teams real money.

How a Vibe-Coding Session Actually Goes

Prompt one: "Create a dashboard for logistics management." The result actually looks good.

Prompts two through five: you refine the layout, add filters, adjust charts, ask for a more unique look.

Then prompts six through twelve arrive: "Why are the filters hidden behind the table? Undo that. And make the table wider." At this stage, you typically stop building and start firefighting.

By the time you've burned through hundreds of tokens chasing your own earlier instructions, the session ends with a result that a junior designer could deliver in half a day. This is what vibe coding actually looks like in practice.

Add it up: $50–200 in Lovable credits, plus 8–12 hours of founder time at a typical rate of $75–150/hour. That's $600–1,800 in real cost for a result that a junior designer would deliver in half a day for roughly $100–200.

The tool that was supposed to save money ended up being the expensive route.

What else is worth mentioning is that burning through tokens is actually a symptom of a broken AI workflow. The root problem is that AI has no long-term vision for your interface architecture, and every prompt is handled locally. When you ask it to move a button, it moves the button. But AI has no way of knowing that the button was visually tied to an element two columns over. You fix one point and break two others. This is the loop.

A designer, in contrast, looks at a screen as a living system where each element is connected to several others. Before moving a single element, they ask: Does this need to exist at all? This question is the foundation of product UX, and it is never asked when you're prompting screen by screen.

Data Visualization Gap

AI reads the data it's given and draws a bar chart or line graph. It doesn't think about what question the user is asking when they look at that data, or which visualization format actually answers that specific question.

The prompt didn't communicate the idea in the specialist's head, let alone what a regular user needs. That's the core difference in how we think. AI looked at the data type (percentages) and picked a visualization to match it. But a designer also looked at the question the user asks when they see this data: "How complete is this?" AI interpreted the question as "what does this consist of?"

So the answers look different and solve different problems.

Cost: anywhere from $0 if the designer catches it in time.

In our case, it was $0, because we caught it ourselves. But that's not always how it goes.

What Gets Lost Between the Prompt and the Screen

AI UI generation is fast. The speed is also what makes it easy to skip the question of whether the screen you just generated actually solves the right problem.

But when you type a prompt into a UI generation tool, you receive pixels that resemble a product. Generative UI gives you the output of a decision process, without the decision process itself.

What you don't get is the layer of thinking that happens before a designer opens their tool. This layer includes:

Understanding what question the user is actually asking when they open this screen
Mapping how this screen connects to the flow before and after it
Identifying which elements are load-bearing for the user's task and which are decoration
Anticipating how the layout behaves when real data replaces placeholder text

We had a SaaS UX project where AI generated a timeline interface: weekly status summaries at the top, detailed reports below. Summary first, details second, and this actually sounds logical.

Except when real users interacted with it, the logic collapsed. A user would open the screen to understand why last week's metrics dropped. They'd read the status summary at the top, scroll down to find the details, lose track of what the summary said, scroll back up, then back down.

A few people even started opening two browser tabs to compare information side by side. This kind of workaround is common with AI-generated interfaces, as users adapt to the tool's logic instead of the other way around.

When we redesigned the layout so the weekly status was located inside the column header of the detail table, the interface became one coherent tool, and the user could answer their actual question in a single view.

This is what AI UX design misses: the layout looked logical in the prompt, but only a real user session revealed how it actually behaved.

Fortunately, we detected this issue at the design stage, and it took us roughly 4 hours of rework at $50–80/hour.

If the same layout had reached development first, we'd be looking at 2–3 days of backend restructuring, and this is $800–2,000 added to the bill.

AI Can Also Break Down Brand Consistency

A client of mine, a founder with a product company, was traveling for two important sales meetings. The presentation for the first meeting was ready. For the second, he opened Claude on the flight and generated 50 slides.

Almost all slides looked this way:

When he landed and showed a designer, they went through the deck slide by slide, and almost every slide had the same problem: it looked like a generic corporate presentation pulled from a template library. The colors, fonts, and visual structure had no connection to the product's brand. A person in that meeting room would have had no way of knowing this came from the same company as the website, the product UI, or the materials from the previous meeting.

We rebuilt the entire presentation before the second meeting. Here’s the new design we came up with:

Ultimately, the client did win new partners from that trip. Whether a polished, on-brand presentation has made the outcome better, we can't say for certain. But we know what visual consistency does: it creates trust. When a company's materials look cohesive, people assume the company knows what it's doing.

AI had no access to the product's visual personality, its tone, its audience's expectations, or the specific fonts and colors those users had seen hundreds of times. Interface consistency is usually developed gradually, across every touchpoint, but AI starts from zero each time.

Visual familiarity builds trust because of a well-documented cognitive pattern in UX called the mere-exposure effect: people trust what they recognize. An interface that works correctly but looks visually foreign creates a discomfort that users feel but can't explain. This is one of the most overlooked problems in AI UX today.

The Investment Question

Some founders plan to skip design investment early and add it later when there's more budget. But the cost doesn't disappear. It just moves to a stage where fixing it is harder.

Reworking a vibe-coded interface that's already in development means going into a live system, understanding what every piece depends on, and changing the structure while the product is running. That's a different category of work from building clean from the start, and it's a recurring pattern in AI interface design projects. And engineering hours spent untangling AI-generated layout decisions can be some of the most expensive hours in a product budget.

Before computers, accountants did all their work by hand. When computers arrived, they didn't disappear. They got faster. UX designers are at that same point now. AI is the calculator. The judgment about what to calculate, and why, still has to come from a person.

And this is the gap AI product design tools haven't closed yet. The calculator got faster. The judgment still has to come from a person.

Budget spent on design before development is an investment. But the same budget spent after development is a repair bill. And this sequence is usually the same across every AI development workflow.

Where AI Genuinely Belongs in the Design Process

AI still has a real place in design work. It's good at one specific thing: executing a clear specification fast. For example:

When a designer needs to explore five different layout directions for a component, AI can produce these starting points in minutes. The designer picks, adjusts, decides. That's a genuinely faster way to work.
AI also handles repetitive UI work, like content variants, iterations on an established component pattern, and microcopy for buttons and labels. When the creative decisions are already made, AI is a good production tool.
For founders, AI is useful for making a rough idea visible before a designer is involved. Used this way, AI prototyping shortens the briefing conversation without replacing the design work. Turning a vague concept into something you can point at and say "more like this, less like that" makes the briefing conversation much shorter.
Data visualization: Ask AI to chart a dataset, and it picks a format based on the data type: percentages get a pie chart, trends get a line graph.

A Practical Approach If You're Already Using AI Tools

If AI is part of your process, here's how to avoid the expensive version of these mistakes:

Define the user's actual question before prompting. What task are they completing? What decision are they making? Write it down.
Treat AI output as a reference. Have a designer review the flow before it reaches a developer. Even a short review catches the critical mismatches between what the screen shows and what the user actually needs to do. This review step is the part teams often tend to drop from their UX workflows when they switch to AI-assisted design.
Include your brand guidelines in the conversation. If you have them, attach them. If you don't have them yet, that's worth solving before generating 50 slides for a sales meeting.
Track your iteration count. If you're on prompt 15 and still adding complexity, stop. That's a signal to step back and reconsider the structure. More pro mpt engineering won't fix a layout at this point.

Final Say

Designers used to hear "we don't need UX, just build it." Now, founders say, "I'll generate the design with AI and hand it straight to the developer." The excuse is different. But the result is still the same: product thinking is skipped, and the cost shows up later.

AI is a real tool, and it speeds up parts of the design process that used to take hours. But faster screen generation doesn't replace the thinking that impacts what these screens should actually do. That part still has to happen, and the earlier it happens, the cheaper the whole project will be.

AI Can Generate Interfaces. It Still Can't Design Products

Katerina Bulkina — Sun, 07 Jun 2026 18:41:25 +0000

My entire team at UITOP uses AI tools every day. I use AI for competitive research and copy drafts. And I use it to fill dashboard screens with realistic data so I can actually evaluate a layout. Tasks that used to take a day now take two hours.

That's exactly why I need to talk about what AI doesn't do in AI product design. Because after a year and a half of working with AI-built products, I keep seeing the same sequence of events. And it keeps ending in the same place: a founder who saved money on design in month one, pays significantly more to fix the product in month six.

The Pattern Starts With a Reasonable Decision

A founder is building a SaaS product. The team is small, and there are tools that can generate a working interface in hours. Lovable, Claude, Figma AI. The logic is clear: why hire a designer when the tool delivers a working interface immediately?

The first three or four months often go well. The product is live, early users are signing up, demo calls are happening. The MVP works. Then the numbers start shifting. For instance, onboarding drop-off climbs, or users open support tickets. The product isn't broken, but it's not converting either. The founder looks at the analytics and sees the problem. The analytics don't explain what's causing it.

This is when I get the call.

What AI Builds, and for Whom

Every AI interface produced by tools like Lovable or Figma AI is built from the most common patterns in their training data. In practice, that means they build for the most cooperative possible user: good connection, calm attention, a modern device, no time pressure.

Your actual user is not always that person:

They open your product on a phone with a cracked screen while commuting.
Their connection drops mid-flow.
They misread a button label because they're distracted.
They tap the wrong option and don't know how to go back. The session times out and their progress disappears.

AI doesn't model such a user. It doesn't generate error states unless you ask for them specifically. And it doesn't build for a screen that's 320px wide and in direct sunlight.

This becomes sharper when you look at AI UX decisions inside generated flows. A UX designer asks these questions. One of my designers was reviewing a Lovable-generated flow and asked Claude directly: Why is this solution structured this way? Claude immediately said the solution needed to be reconsidered. The screen looked fine. But the logic behind it didn't hold up to one direct question from a specialist.

Where Users Actually Leave

SaaS UX problems are most visible in onboarding. This is usually where products built solely with AI lose the highest percentage of users, and it's rarely obvious why from the data alone.

A user registers. The next screen asks for their company name, number of employees, and billing plan. They haven't seen the product do a single useful thing yet. They fill it out because they're still curious.

Next, they're asked to select from a set of cards with labels they don't recognize. They pick the first one and reach the dashboard. The dashboard is empty, no data, no guidance, no indication of what to do next.

They click around, land in settings, then go back, try another button. At some point, they can't tell if the product is broken or if they're the ones using it the wrong way. This moment of uncertainty is where you lose them. They close the tab, don’t come back, and your follow-up emails go unread.

You can see the drop-off in analytics. What analytics won't tell you is what the user was thinking on each screen, or which specific moment made them give up. That's a research question, and it requires talking to users and watching session recordings.

The Problem With Chat-First AI Products

A growing number of SaaS products are built around an AI chat interface as the primary interaction model. The logic makes sense: let the user type what they need, and the AI handles it. But conversational UI introduces a specific design challenge that tools don't solve on their own.

Chat interfaces remove the guardrails. In a traditional UI, buttons and menus constrain what the user can do. In a conversational flow, the user can type free-form input, and the product needs to handle it gracefully.

Chatbot UX failures are often invisible in early testing because founders test with clear, well-formed inputs. Real users don't write clear, well-formed inputs. They write fragments, use wrong terminology, or describe the outcome they want instead of the action they need.

Why AI-Built Products All Look Like Each Other

There's also a visual pattern I notice across AI-generated SaaS products: gray sidebar, blue primary button, Inter font, clean card layout. Such an interface is indistinguishable from the five competitors your user evaluated last week.

Think about the car industry in the 1970s and 80s. A Cadillac and a Citroën were immediately recognizable. Their visual identities were so different you could identify them from across a parking lot. Then, manufacturing standardization and aerodynamic requirements pushed every car toward the same optimal shape. Today, a Hyundai Tucson and a Lexus NX have nearly identical silhouettes. You walk up to find the badge.

SaaS products built on AI tools are going through exactly this. The tools produce what works across most contexts, which means they produce the same output for every product.

Your own visual identity is what shapes AI user experience in a way that sticks. A user who can't remember which product they used last Tuesday will not renew. AI tools don't have a point of view, so they can't give your product one.

Then, There’s a Code Problem

Here's a scenario I worked through recently. A team used Lovable to build a prototype. It looked sharp, and demos went well. But when the time came to build the actual product, the tech lead reviewed the prototype code to plan development.
His estimate was three days. The feature should have been roughly 1,000 lines of code. However, Lovable had generated it in over 10,000 lines.

Ultimately, the developer spent weeks untangling code that a designer-led process would have delivered cleanly. The budget goes into the product either way. The question is whether it goes in at the beginning, when you're making decisions, or at the end, when you're paying to undo them.

Poor AI SaaS UX foundations compound this problem: when the interface logic is inconsistent, developers have to build compensating logic into the code, which makes the entire system harder to maintain.

A designer working from a proper design system hands off named components with consistent variables directly usable in a developer's project. This is standard practice in professional design work. AI-generated output skips this entirely, so developers build the system themselves from the code up, which takes much longer and produces more inconsistencies.

Where AI Genuinely Cuts Time

The answer to all of this isn't to stop using AI tools. It's to integrate them into a disciplined AI workflow where a specialist controls the decisions.

Client prototypes. Building an interactive prototype in Figma and then spending the first ten minutes of a demo explaining which parts are clickable is a waste of a demo call. Lovable generates a working prototype in hours, the client opens it in a browser and walks through it on their own, and the conversation starts from a much more useful place.
Realistic screen data. A dashboard with placeholder text tells you very little about whether the layout works. You need to see what happens when a company name is 47 characters, when a value is negative, when there's no data to display. AI can populate a screen with realistic data in minutes.
Competitive research. Reviewing ten competitor products, mapping their navigation patterns, identifying where they make the same decisions and where they diverge: this used to be a full day of work. With AI, it takes a couple of hours. The analysis is still the designer's. Yet, the time to gather the raw material is just shorter.

The Decision You're Actually Making

If you build with AI tools alone, you're likely making a specific trade: faster output now in exchange for more expensive fixes later. Sometimes, this is right. Getting to market matters.

But it's worth understanding clearly what you're trading.

Before generating a single screen, a team with a UX designer answers: who exactly is this product for, and what task are they trying to complete? Then: what happens when that task goes wrong? This work takes days. It shapes every design decision that follows.

UX designers working with AI tools are completing tasks in roughly half the time they used to. The savings are real. They come from a specialist using AI as an instrument. AI product UX done well is the product of that combination: the speed of the tool, the judgment of the person.

There's a principle in development: if you can't code, you can't vibe-code. You need to understand what you're generating to make good decisions about it. The same applies to design. AI amplifies what you already know.

Three Questions Before You Open a Design Tool

If you're building a product right now, or evaluating one that's already live, start here:

Who is your user, specifically? Not the ideal user with full attention and a perfect connection. The real one, in a real context, with a real reason to be distracted.
At which step in your onboarding do users drop off, and do you know what they were thinking at that moment?
Can a new user reach the first useful action in your product without any help from your team?

If you can't answer all these questions confidently, that's the design work that needs to happen before you generate another screen. AI will make this work faster once you've done it. But it won't do it for you.