I use AI every day. For scaffolding, for quickly turning messy notes into readable documentation, for writing out component logic I already know but don't feel like typing. It saves me hours. And yet: the moment I ask AI to build an interface that actually looks good, or to solve a complex interaction where multiple states need to stay in balance, it falls apart.
Not a little. Completely.
Recently, an article by Adam Argyle (CSS DevRel at Google) circulated on exactly this topic. The comments confirmed what I've been sensing for a while: AI is good at the mediocre, and stumbles the moment things get interesting.
That deserves an honest analysis. Not to dismiss AI, but because it reveals something important about what frontend (and UX) actually is at its core.
What AI does well
Let's be fair: for generic patterns, AI is excellent. Setting up boilerplate, writing a standard form validation, store something in localhost. Things you'd do on autopilot yourself, but where you still have to think about the right syntax.
That "boring stuff" isn't unimportant. A large part of what we build is just solid execution work. And AI genuinely helps there.
The problem is that AI also thinks it's excellent at the hard things. It hands you a component with full confidence while there's a gaping hole where an icon should be. And when you point it out, it says cheerfully: "You're absolutely right, let me fix that." It didn't know it was wrong.
Where it goes wrong: four structural problems
1. It trained on old and mediocre work
The internet is full of outdated CSS solutions, copy-paste tutorials, and generic UI patterns. That's the material AI trained on. Modern CSS, like container queries, cascade layers, scroll-driven animations, logical properties is barely represented in that dataset.
Ask AI to build a layout using modern CSS, and you get something that works in 2018.
2. It can't see the page
This sounds simple, but it's fundamental: an LLM is not a rendering engine. It can reason about CSS, but it doesn't see the result. It has no sense of how elements relate to each other in a browser, how spacing feels, whether a line is just slightly too heavy.
Visual judgment requires visual feedback. AI doesn't have that.
One commenter put it well: AI "digests" a design and then builds something similar, but not the actual thing. A lossy textual interpretation instead of the real deal.
3. It doesn't understand the "why"
This gets to the core of it. When I build a component with a specific interaction, I have a reason. That reason is rooted in how users learn the product, which actions are primary, how the interface should feel on a busy screen. That's context that doesn't fit in a prompt.
AI knows the mechanics. It doesn't know the motivation.
One comment from the discussion put it sharply: what models lack is "intention, motivation, and the experience of countless failures." They have to infer what you want from a handful of tokens. The results are actually surprisingly good given that, but they're never from a designer.
4. The browser is an uncontrolled environment
CSS and HTML run in an environment nobody fully controls: different browsers, versions, screen sizes, input methods, user preferences, accessibility settings. Each of those variables affects the final result.
Python always runs the same on version 3.11. A browser doesn't.
AI ignores those variables unless you explicitly name them. And even then, there's no guarantee it takes them into account.
The comparison that stuck with me
One comment drew a parallel with CSS frameworks like Bootstrap: great for a quick prototype, fine when you don't care about the details. But the moment you start customizing, bringing in your own ideas, or implementing a specific design you start working against the framework instead of with it.
AI-generated frontend works exactly the same way. On the paved road, it's usable. The moment you deviate, you pay the price.
What this says about our work
There was a popular opinion in 2023 that frontend developers would be the first to be replaced. Too executional, too mechanical, too easy to automate.
That idea rests on a fundamental misunderstanding: it confuses "being able to type things that work" with "knowing what to build and why."
The real work in frontend and UX is invisible. It lives in the decision of which state gets priority. In the trade-off between consistency and context. In sensing that a particular interaction takes just a beat too long, or that a text on mobile doesn't quite breathe right. In understanding how a user will move through a screen before they've thought about it themselves.
One commenter said it well: "We're coding UX solutions, and there's no debugger for those."
AI can't have taste. It can recognize patterns that correlate with "liked by many people", but that's something fundamentally different.
How I use it
AI is, for me, a fast junior who's good at straightforward execution work and never gets tired. I give it clear tasks with a defined scope. Scaffolding, conversions, repetitive logic.
What I never ask it: judge whether this feels right. Figure out how this component should behave when states conflict. Build something that doesn't look like everything else out there.
That's my work. And honestly: I'm glad it still is.
