Claude isn't a Figma killer. That framing gets clicks, but it misses what's actually happening, and what's actually worth worrying about.
After nearly twenty years designing websites and products, I'm not anxious about AI taking the work. The work is changing. A lot of that change is good. What I keep circling back to is something more specific: a junior designer, a founder, or a PM can now spin up a landing page or a product surface that hits 90% on their own. It looks shippable. Sometimes it ships. And that's where the trouble starts.
90% is a sneaky number
90% reads as "almost there."
In web and product design, 90% is actually "load-bearing problems hidden under a nice Dribbble shot."
A homepage built to 90% looks fine on a 14-inch laptop in light mode. Cool. Now open it on a Pixel. The hero crops weirdly. The CTA fails contrast. The font stack falls back to Times on Android because nobody set up font loading correctly, so your premium brand now reads like a 2003 book report. The CMS has three different components that all render a "card," none of them aware of each other. Marketing adds a fourth next quarter because they couldn't find the first three. Now you have four cards. Congratulations.
A product app at 90% has modals that trap focus incorrectly, toasts that announce themselves to screen readers as gibberish, and color tokens named after the color instead of the role, so when the brand refreshes, half the app has to be repainted by hand. Oh, and twelve subtly different button styles, because every feature team rolled their own and nobody felt like having the conversation.
None of that shows up in a demo. All of it shows up six months later, when the team is moving slower, the bug list is full of "small visual issues," and somebody starts whispering the word "redesign." That's the credit card bill. The interest is engineering velocity.
What the last 10% actually is
The last 10% is the part nobody screenshots. It's also the part that determines whether what you built can grow.
Token discipline. Color, spacing, radius, type, motion, all defined semantically surface/raised, text/muted, space/inline-sm, not literally gray-200, 16px. Done right, a brand evolution is a token update. Done wrong, it's a six-week project and somebody's weekend.
Component governance. A real component library has owners, contribution rules, deprecation paths, and a way to say no. Without governance, your library becomes a graveyard of one-offs labeled ButtonV2Final_actuallyfinal. We've all seen it. Some of us have made it.
Accessibility past the audit. Not just contrast and alt text. Focus order, keyboard traps, ARIA semantics that match actual behavior, motion preferences, error messaging a screen reader can parse. AI tools will happily generate inaccessible markup that passes a casual eye test, which is roughly the same as a smoke detector that only goes off when there's no fire.
Responsive and state coverage. Empty states, loading states, error states, long-content states, zero-data states, permission-denied states. The 90% version has the happy path. The shipped-and-maintainable version has all the other paths, designed deliberately, not improvised at 11 PM by whoever picked up the ticket.
Content architecture. On a marketing site: how page templates compose, how the CMS models content, how a non-designer adds a new case study without breaking the grid or accidentally publishing a 4,000px image. On a product: how settings scale from 5 to 50, how navigation holds up when you add a fifth top-level area without bullying the other four.
Naming and documentation. What this component is called, when to use it, when not to, what it depends on. Future-you and every engineer after you are reading this. If it isn't written down, it doesn't exist, no matter how clearly you explained it in Slack that one time.
The fights with engineering. Why we can't add one more button variant. Why this needs to be a primitive, not a one-off. Why the "small" change to the input component is actually six weeks of regression testing. Design systems exist because we kept losing those fights and finally just wrote down the rules so we could stop having the same conversation every sprint.
Why this matters now
The reason I keep coming back to this isn't gatekeeping. It's that the gap between "looks done" and "is actually done" used to be visible. You could tell a rough prototype from a real product at a glance. AI-assisted output blurs that line.
The surface quality jumps way up, while the systems thinking underneath stays exactly where the operator's experience left it.
Someone who's shipped and maintained real products knows what the last 10% costs because they've paid it, usually more than once, usually on a Friday. They know what a token system saves you in year two. They know why the button needs an owner. Someone hitting 90% for the first time doesn't know what they're not seeing, and the tools won't tell them. The tools are too polite for that.
That's the thing worth paying attention to. Not "AI is replacing designers." A wave of work that looks finished, ships, and quietly compounds debt that someone, eventually, has to pay down.
