Design needs a rebrand. For the last 10 years or so the design community has been screaming "it’s not about how things look, it’s about how things work." There’s an entire podcast about this, 99% Invisible, and within the design community, the message landed.

Designers get it.

Nobody else does. Nobody else cares.

When you say "designer" people picture someone picking colors, debating fonts, making things pretty, and building an interface. The word is polluted, and with agents, that pollution is expensive.

The Interface Was the Design

Up until now, design meant interface design. The UI was how humans interacted with a system, so designing that interface was designing the experience.

Book a flight on United. You enter your dates. Select your flight. Choose your seat. Agree you won’t bring bombs and batteries. Enter traveler info. Enter payment. The flow forces the sequence because the system needs all that information, and humans are bad at giving structured data unprompted.

Our designs tried to make unpleasant information gathering complete... and pleasant.

It was annoying, but it worked, and was necessary because this is how traditional CRUD apps function. The interface constrained the human so the system could process the request.

Agents Break the Wizard

Agents simply don’t work like this. A good agentic interaction feels like talking to a competent executive assistant. "Book me a flight to Austin next Tuesday, afternoon if possible, aisle seat, use my United account." That one sentence contains dates, preferences, loyalty info, and seat selection, out of order, at once.

The AI still needs the same information the wizard needed. But you don’t want to force a sequence. It should handle whatever the human throws at it, extract what’s relevant, ask for what’s missing, and avoid asking for things it should already know.

This is a design problem. It’s just not what most people think of when they hear "design."

The Verbose API Problem

Agents don’t just interact with humans, they interact with backends. APIs. Databases. The works.

But, APIs weren’t designed for agents. They were designed for developers writing code with specific endpoints in mind. So they look like:

• Verbose payloads: wasting tokens describing fields the agent doesn’t need
• Multi-call workflows: where getting a flight requires one call to search, another to price, another to hold, another to book
• Inconsistent schemas: where dates are formatted differently across endpoints
• Missing context: the API doesn’t tell the agent what fields are required vs. optional

A human developer handles this by reading documentation, learning the quirks, and writing code that accounts for them. An agent will need to figure it out on every request, burning tokens and making mistakes.

This is also a design problem. The API’s design, its structure, determines whether agents can use it effectively. Including how documentation is structured.

The Chat Trap

The lazy response to agents is recreating the wizard in chat form.

"What dates are you traveling?" "Where are you flying from?" "Where are you flying to?" "What time do you prefer?"

This sucks...

The whole point of an agent is fluidity. I want "Tuesday to Detroit, afternoon, aisle". The moment an agent starts interrogating you one field at a time, the wizard UI is probably better.

So, designing for agents means designing for ambiguity. Incomplete information, out-of-order inputs and implicit context. The agent should feel like an assistant that infers what you want.

Just Fucking Rebrand

Designers have spent years saying "we do more than make things pretty." It’s failed outside the design community. Most product managers, engineers, and executives still think of design as visual, and their working artifact is "the designs". Putting an "experience designer" on API architecture feels weird.

In context the argument, that design is how things works, it makes sense but we need to drop the word "design"

"Designer" it has baggage. The visual association is too strong. And the work that agents require, context architecture, API ergonomics, conversation flows, token efficiency, it just doesn’t fit the mental model people have for design work.

We need a new word entirely. Agent architects. Context architect. Experience engineers, idk. Something will stick, but not with "design" and tacking another word before feels like a half-assed rebrand.

What Is An Experience Engineer

The title is still unclear, industry will have to reach consensus, but it is clear what the job is:

For human-agent interaction:

• Handle partial information gracefully and naturally
• Don’t recreate wizards as a chat
• Make capabilities discoverable through conversation
• Remember the right context across conversations

For agent-system interaction:

• Minimize API calls per task
• Keep payloads concise, don’t send fields agents don’t need
• Use consistent schemas across endpoints
• Make required vs. optional fields explicit
• Documentation needs to be written for an Agent
• Build for inference, not just spec

For integrated products:

• Take the lead on evaluation; build appropriate monitoring and oversight
• Define “good enough” for a given scenario
• Anticipate risks and proactively mitigate harms
• Track customer opinion and advise accordingly

Think about rollout, adoption, training and transition states Same Craft, New Diggs

Design has evolved from graphic design to web design to product design to experience design. Each time, the word "design" barely held on.

This shift will be the one that breaks it. Experience Engineering (still not convinced it’s the right one) requires thinking about systems, APIs, token economics, and conversation flow. It’s feels closer to engineering than to visual design, but it’s not engineering either. It’s its own thing.

The designers who figure this out will be incredibly valuable. The ones who cling to interfaces and visual systems will find less work to do.

Frankly, the work is changing whether or not the title catches up.

---

The interface was the forcing function. Agents don’t have that luxury. Design in the age of AI means designing for ambiguity, and that requires a kind of design most people don’t recognize yet.

‍