AI is eating the interface

Something strange is happening.

Today, I can ask AI to summarize a doc, rewrite a paragraph, or draft a pitch—without ever touching a dropdown, menu, or modal. There is no interface. Just a cursor blinking, waiting for me to think out loud.

This isn’t just convenience. It’s a tectonic shift.

The interface is disappearing—because AI is becoming the interface.

Designers aren’t losing relevance. They’re losing their old job description.

It’s easy to think AI is replacing design.

Tools like Google’s Stitch or Figma’s AI features can generate wireframes, write copy, and even export code. Startups are pitching no-designer-needed workflows. And increasingly, products don’t have screens at all—they have chat interfaces, voice agents, or invisible background automations that respond to intent, not interaction.

But here’s the truth: design isn’t being automated. It’s being redefined.

Because when AI becomes the interface, the work of design shifts from drawing buttons to shaping behavior, language, context, and trust.

You’re not designing what people see. You’re designing what the system does when they say what they want.

Just like the mobile revolution, we’re in the messy middle.

If this all feels vaguely familiar, it should. When the iPhone launched, designers didn’t have established patterns for touchscreens. We made mistakes. We shipped bloated desktop pages with tiny buttons. We relied on shadows and gradients to fake physical affordances. And then slowly—through trial and error—we figured out what worked. Gestures. Tab bars. Edge swipes. Pull-to-refresh.

We’re in that moment again.

AI is the new touchscreen. The input is different. The output is unpredictable. The UX paradigms aren’t set yet. And that means the work is wide open—for the designers willing to shape it.

New interfaces still need old instincts.

Even as the surface area of the interface melts away, the foundational principles of design haven’t gone anywhere.

• Clarity still wins. Even in a chat interface, unclear labels, vague responses, and poor error handling break trust.

• Feedback still matters. If AI does something behind the scenes, the user still needs to understand what happened—and why.

• Affordance still applies. Users need cues for what’s possible, even in conversational UIs. Buttons, suggestions, tooltips—these are still scaffolding for interaction.

• Accessibility still counts. If your AI experience only works for fast typers or fluent English speakers, it’s broken. Design for real people, not just demos.

Good design isn’t going away. It’s just showing up in new places.

Jakob’s Law still rules—maybe more than ever.

One of the most misunderstood truths in UX is that users don’t want new experiences. They want familiar ones that help them get new things done.

That’s Jakob’s Law: people spend most of their time using other products. So they expect yours to work the same way.

In the AI era, this law becomes even more important. Because when users don’t see a clear UI, they fall back on mental models—what they’ve seen before, what they assume is possible.

If your AI system behaves inconsistently, speaks in a different tone from your product, or changes its output every time, you’ve broken the invisible contract with your user. And that means they won’t trust the experience—even if it’s “magical” on paper.

We don’t just need good prompts. We need good paradigms.

Skeuomorphism wasn’t a gimmick. It was a bridge.

Remember when every app icon looked like a leather notebook or a shiny control panel?

Skeuomorphism made software feel familiar when computers were still unfamiliar. It wasn’t just aesthetic—it was cognitive glue. Users needed help understanding what buttons did, what sliders were for, and why you could drag things across a screen.

Once people got used to digital, skeuomorphism faded. Flat design took its place. Interfaces could get cleaner, simpler, more abstract—because the user’s mental model had caught up.

We need that same bridge now.

AI is powerful, but unfamiliar. Most users don’t know what to ask, what’s possible, or how the system will behave.

So we need to build bridges—transitional patterns, scaffolding, visual cues, and language that eases people into this new way of interacting. Don’t throw users into a blank chat box and expect them to figure it out. Show them what to try. Guide them through it. Reduce ambiguity.

AI needs affordance, just like every interface before it.

What great design looks like in the AI era

Designers are no longer just arranging pixels. We’re shaping interactions, personalities, and systems of behavior.

That means we need a new toolbox. Here’s what’s working:

• Suggested actions. Don’t make users guess what to ask. Offer them good prompts.

• Tone design. Chat interfaces are UX. The personality of your AI—polite, concise, helpful—matters as much as visual design once did.

• Confidence levels. Let users know when the AI is guessing vs. when it’s sure. Overconfidence breaks trust.

• Source transparency. Show where AI outputs come from. Let users verify or explore further.

• Undo and edit. Users need control. Make it easy to revise or roll back what the AI just did.

• Feedback loops. Give users a quick way to rate, correct, or improve AI outputs—and actually learn from that feedback.

This isn’t theory. This is what’s working in production products right now.

And it’s just the beginning.

AI won’t kill design. But it will make lazy design obsolete.

The rise of AI is exposing a brutal truth: a lot of what we called “design” was just decoration.

Pixel polishing. Layer naming. Endless variants of the same modal. That kind of work is being automated—and that’s a good thing. Because the future of design is deeper.

It’s behavioral, systemic, probabilistic. It’s about shaping how intelligence shows up—how it helps, when it stays quiet, and how it earns trust. And that’s not something AI can do alone.

The job of the designer isn’t to control the interface anymore. It’s to shape the experience around intelligence. And the work of design is just beginning.