When agents can make the UI, what does the designer still own?

We learnt this directly in a GenAI recommendations experiment at SEEK.

We built a conversational experience that asked candidates about the role they wanted next. Instead of filling in a static form, people responded to dynamically generated questions and answers. The interaction worked by its own measures: it captured 10× more preference signal than traditional search, and roughly 85% of people who started completed all eight questions.

Then the outcome data arrived. Apply conversion fell 4%, and job-detail views per visitor also declined.

The interface was engaging. The model learnt more. The product got worse at helping someone find a job.

The problem was fit. We had put a thoughtful conversation in the middle of a high-intent moment. Someone had arrived to see jobs; we answered with questions. Worse, after giving the system all that context, candidates did not see their recommendations improve enough in the same session. We collected trust before we had earned it.

No amount of polish could fix that. The important design decision was not how the conversation looked. It was whether the conversation belonged there at all.

That distinction becomes more important with generative UI. An agent can make a locally convincing interface while missing the larger product moment. It can optimise the answer and still fail the person.

If components and layouts become outputs, design moves up a level. The work is to define the conditions under which an interface deserves to appear.

I think that judgement has four connected parts: fit, memory, trust loops, and product learning.

Fit is whether the product shows the right thing to the right person at the right moment.

A generated interface can be relevant to a query and still be wrong for the situation. It can ask for useful information when someone is trying to act. It can offer a rich explanation when reassurance would be enough. It can make a high-confidence recommendation when the available evidence only supports a question.

Designers need to set the editorial rules behind composition:

• When should the agent ask, suggest, explain, act, or stay quiet?
• What is the user's goal at this point in the journey?
• What interruption cost are we asking them to pay?
• What evidence justifies showing this component now?
• When should a rule be a constraint, and when may the agent override it?

I ran into this while building a generative UI for my personal knowledge base. My first version reliably turned a stand-up query into the same three-column stand-up component. It was tidy and predictable, but it ignored the shape of the underlying knowledge. I had built a dashboard that thought it was generative.

The breakthrough came when intent stopped being a fixed mapping and became a prior. The agent could inspect the dominant pattern and relationships in the data, then choose an entity view, contradiction, graph, or timeline when that better explained what was happening. The components mattered, but the real design was the rule for choosing among them.

Protocols such as A2UI make it possible for agents to describe an interface and for clients to render it safely. They do not decide whether that interface fits the human moment. That remains a product decision.

(Also see the practical companion to this section: the AI memory pattern library.)

An adaptive product is always making claims about what it knows.

"Because you told us you prefer hybrid roles."

"Based on jobs you viewed recently."

"You said you were not interested in agency work."

Those claims create obligations. The system needs to know where a memory came from, how confident it is, whether it is still current, where it may be used, and how someone can change or remove it.

Designers therefore need to shape memory as part of the experience, not leave it as an invisible data concern. That includes:

• the difference between something a person said and something the system inferred
• when a preference should persist and when it should expire
• how conflicting signals are resolved
• how the product shows what it remembers
• how a person can correct, delete, or scope a memory
• when the honest response is "I don't know yet"

Without these decisions, personalisation becomes accumulated guesswork. The agent may sound attentive while acting on stale or inferred context as if it were fact.

Memory is not valuable because the system can retain more. It is valuable when it helps the product respond better without misrepresenting the person.

AI products often include the appearance of control: thumbs up, thumbs down, "not relevant", "try again". The important question is what those controls change.

If someone corrects the agent and the next result repeats the same mistake, the interface has not created a feedback loop. It has created feedback theatre.

A real trust loop lets a person:

1. understand why the system did something
2. correct the relevant assumption
3. see what changed as a result
4. inspect or undo consequential actions

The size of the loop should match the risk. Saving a job might need an easy undo. Applying for one should require clear intent and confirmation. Changing a durable career preference should reveal where that preference will be used.

This is where designers define the agent's permission boundaries and recovery behaviour. What can it do independently? What must it preview? What requires approval? What should be logged? When should it hand control back?

Trust is not a tone-of-voice layer added to an autonomous system. It is the experience of being able to understand and influence that system over time.

Every adaptive interface is also a research instrument. It asks questions, observes behaviour, captures corrections, and sees outcomes.

But more signal does not automatically mean more learning. The SEEK experiment made that clear. Capturing 10× more information looked like success until we compared it with the outcome that mattered.

Designers need to connect what the interface captures to what the product is trying to learn:

• What hypothesis does this question test?
• Is the signal explicit, inferred, or behavioural?
• Does it improve the current experience or only a future model?
• How will we know the recommendation became better?
• Which outcome could disprove our assumption?
• What will the team change when the evidence disagrees with the interface metrics?

Product learning closes the larger loop. A person's correction should improve their experience. Patterns across many corrections should improve the product. Outcome data should improve the rules that guide the agent. And the team should be able to trace those changes rather than treating the model as a black box.

The designer's role is to make that loop intentional. We are not only designing what the system says today. We are designing how it becomes more useful tomorrow.

This does not mean components, patterns, flows, or visual craft disappear. Generated interfaces still need a coherent language, accessible rendering, clear hierarchy, and sensible interaction states.

But those are no longer the complete specification.

The design artefacts now also include:

• component semantics and the situations in which each component is appropriate
• composition rules, priors, and override conditions
• memory provenance, confidence, scope, and expiry
• permission levels, confirmations, and undo paths
• evaluation sets for good, bad, and unsafe outputs
• feedback loops that connect a correction to a visible result
• measures that link model behaviour to human and product outcomes

These may live in prompts, schemas, evals, policy documents, code, or design-system guidance. Their format matters less than whether the team and the agent can use the same context.

The designer is no longer handing over a picture of the interface. They are helping define a system that can make many interfaces without losing the product's intent.

UI generation makes production cheaper. It does not make consequences cheaper.

As agents gain more freedom to compose and act, a product needs stronger answers to basic questions: Why this? Why now? Based on what? What happens if it is wrong? What will change when the person responds?

Those questions are design work.

The future role of the designer is not to compete with the agent at drawing every screen. It is to give the system the context, constraints, and learning loops required to exercise good judgement — and to recognise when it has not.

The agent can narrate the experience.

The designer still owns its conscience.

Richard Simms is Principal Product Designer at SEEK, where he leads design for the Career Discovery Agent and Career Feed. He also builds Sentiuma, a personal AI knowledge infrastructure layer.