Writing · 5 min read

What makes a good product designer now?

Designing the system every builder works from, person or agent, and deciding what it must never decide alone. Coding agents can build a working interface in an afternoon, so the scarce work is behind the screen.

Building got fast, so a bad decision travels further

Design used to take months

  1. Research
  2. Design
  3. Spec
  4. Build
  5. QA

Now it takes days

  1. The system
  2. Agents build
  3. Checks
  4. A person decides

Each answer goes back into the system

For most of my career, design ended at the handoff. I drew the blueprint, someone else built it, and months later we found out what survived.

Now I build what I design, with coding agents, and a working version of an idea takes days instead of a quarter. That sounds like a story about speed. I think it’s a story about where the mistakes go.

When building is cheap, the expensive mistakes move. A badly drawn screen used to cost one screen, and someone caught it in review. A badly written rule now repeats on every screen an agent builds from it.

So the work moved too, into what the building is made from. What’s new is that the next builder may not be a person.

How the work runs once agents build
  1. The systemwhat each part means, the rules, the checks
  2. People and agents buildfrom the system, in days
  3. The checksevery change has to pass them
  4. A person decideswhat the checks can’t, and the system keeps the answer

A design system now has to explain itself to builders who can’t ask

A new designer learns a design system from its pages and from the people around them. When something is unclear, they ask. An agent builds from what’s written down, and it doesn’t ask.

In Agent Review, my prototype for supervising agents, a simulated agent moves the billing settings of Relay, a made-up app, onto the design system. For a hand-built gray link, “Cancel subscription,” it recommends a quiet variant of the Button.

The checks pass with the gray link or the quiet Button, and only a person could say the gray was left over from a retention test nobody turned off.

So the cancel link becomes a Button in a change of its own. Then I write a rule for the next agent: on billing, nothing that ends or reduces a subscription gets a quiet variant.

What a component has to carry once an agent builds from it
  1. Lookscolor, type, space: what most systems write down
  2. Meanswhat it signals, and whether that’s on purpose
  3. Behavesits states, its errors, its motion
  4. Applieswhere it holds and where it doesn’t
  5. Ownerwho may change it, and who approves

A component that only says how it looks will be used everywhere it looks right. One that says what it means, and where it doesn’t apply, can be used well by a builder who has never met the team.

Build to find out, not to produce more

The time fast building saves can go to making more, or to learning faster. I think only the second is the job.

Lucy Learns, the dog-training app I built for our household, started with voice commands. Say “next step” and the app moved on, and Lucy took every command as meant for her.

What a working prototype is for
  1. A questionthe thing that makes the next step risky
  2. A working versionreal code, in days rather than months
  3. Real usethe people who would use it, on real inputs
  4. Evidencewhat held, and what broke
  5. A callbuild it, kill it, or park it

A working prototype is a question, asked in a form people can answer. It should end in a call, made on what people did with it.

Decide what software does alone, and where a person decides

Software used to wait for someone to press the button. Now it can take the action itself, and where it stops to ask is a design decision.

Agent Review sorts every change an agent makes into three kinds, and only two pause for a person. The cancel link was one of them: only a person knew why it was gray.

Three kinds of work, and who decides each
  1. Proceeds on its ownclear instructions, allowed, and the checks pass; recorded
  2. Needs judgmenttwo fair answers, or a fact only a person knows; a person decides
  3. Needs approvalreaches past what the agent was given; its owner approves
The terracotta trellis again, closer, its black vine following the lattice, and one shoot that grew off the lattice into empty ground cut cleanly, the cut piece lying below it with a dusty-rose cut face.
The line where a person decides: the system carries what grows along it, and someone still chooses what is cut back.

Agent Review’s main story is the second kind: in Relay, one press archives a batch of customers, active ones included, with no way back. Fast cleanup and nothing lost are both fair asks, so the agent asks me which comes first.

I say nothing lost, and the agent recommends a review before every batch. The prototype’s session notes, which I wrote to show what testing could turn up, have people pressing through its question by the third batch without reading it. Were they deciding, or clicking?

I choose undo instead, with active customers named before the press. A question people answer every time stops being read, so it protects least on the day it matters.

An approve button is the same: if the person can’t see the evidence, the consequence, and a way back, their yes is a formality.

It’s the job I started with, at a longer reach

I started in 2005 as a hybrid designer and developer, then spent thirteen years at RBA on enterprise products, where many hands built and nobody reviewed every screen.

Twenty years, three eras, one job
  1. Craft, 2005designing and building, one job
  2. Systems, 2013the standards other teams built from
  3. Agents, 2026both again, at a longer reach

Now some of those hands are agents.

So quality has to live in checks, from the SAP program to this site:

The checks behind three pieces of my own work
12
checks run on every merge to this site, six of them in a real browser
40+
apps under one design system and one release check on the SAP program
12
design rules a coding agent reads before it builds, in Agent Review’s experiment

A check is a design decision that keeps being made after the designer has left the room.

This year designing and building came back together. I design the system good work comes from, build enough of it to know it holds, and decide, with the people who own the product, where a person stays in charge.

None of this makes the craft matter less. A check can hold the spacing. It can’t tell you whether the thing is worth using, so someone still has to go and look.

What I’d ask a designer now:

  • Can they say what a component means, not only how it looks?
  • Have they built something real, and changed their mind because of it?
  • Can they say where an AI feature should stop and ask?
  • Do they write the checks, or only pass them?
  • Do they still go and watch someone use the thing?