I opened my laptop as soon as I woke up. The agent I had left running overnight had built an entire feature. Twelve files had changed. I read the first few lines, then started scrolling and approving. The tests passed. The feature worked. That morning, I felt I had accomplished a lot.
Around lunchtime, a colleague asked why I had written one part that way. I opened the code again. I had approved it, yet it felt unfamiliar. I could not explain the alternatives or why this implementation had won. The feature was finished, but I could not explain the reasoning behind it.
Delegating the coding had been a good decision. The agent had done its job well. But I had also delegated the criteria I should have set at the start and the reasoning I should have understood at the end. Automation had increased my output. I could not identify what I had actually decided that day.
Software has a different kind of user
People read screens and press buttons. Agents call functions and interpret responses. Even when they use the same service, they need different interfaces. A screen designed for a person does not automatically provide everything an agent needs to use the service reliably.
Agent Experience, proposed by Netlify co-founder Mathias Biilmann, addresses this change. It concerns how agents discover a service, understand its capabilities, and complete work with it.1 I read the idea of Agent First in that context: designing interfaces, documentation, and callable specifications around the work an agent will perform.
I agree with that direction. If agents are going to do the work, the product should make that work straightforward. Giving them a clear way to invoke a function is more sensible than making them search a human interface for the right button. Helping an agent work effectively is one requirement of good design.
Human interfaces, however, have combined controls with explanations. They have helped people define a task, see the consequences of a choice, and correct a result. As we create interfaces for agents, we also need to decide how people will continue to do those things.
Approval counts do not measure judgment
Ten approvals do not necessarily represent ten considered decisions. Once clicking becomes a habit, another confirmation dialog may leave understanding exactly where it was. There had been plenty of approval steps on the morning when I read a few lines and skipped the rest.
The useful questions concern the work itself. Did the person define the desired outcome and constraints? Can they see which assumptions and alternatives shaped the result? Can they point to a problem and change it? Evidence of judgment lies in what a person understood and could change, rather than how many times they clicked.
For a coding task, a person might set the success criteria before the agent implements and tests the feature. The result could present the key choices and validation results first. Revised criteria would then guide the next execution. A person would not need to perform every implementation step to explain what was built and why they accepted it.
Explanations should make verification possible
An accurate result and an understood result are different achievements. Passing tests means the conditions written into those tests were satisfied. Whether those conditions match the original intention remains a separate judgment. A confidence score or a success indicator provides little help with that distinction.
Anthropic's citation feature links an answer to specific passages in its source documents.2 The valuable detail is the connection between a claim and material a person can inspect. A reader can examine the passage and consider how the answer follows from it. A useful explanation gives people material to check a result for themselves.
A citation alone does not ensure that anyone will review it. Someone still has to ask whether the passage supports the conclusion and which conditions have been left out. The product should make that review easier. A person should be able to select a particular sentence or assumption, ask about it, and revise that part without restating the whole task.
People need their own AX
I use Accountability Experience to describe an experience in which people can understand an agent's work, intervene when necessary, and take responsibility for the result. It shares an abbreviation with Agent Experience, so spelling out both names is the clearest way to introduce them.
These conditions depend on one another. Understanding what is happening lets a person decide whether intervention is warranted. Their intervention must affect the result if they are to be responsible for that decision. They also need the organizational authority to revise or reject it. Understanding, intervention, and responsibility need to connect within the same task.
Agents need an interface that supports execution. People need one that supports judgment. There is no reason to implement both with identical screens and controls. The commands an agent invokes and the explanations a person reviews can take different forms while addressing the same goal and result.
Next time, I should be able to explain why
If I designed that morning again, I would define a correct outcome before handing over the coding. When the result arrived, I would read the important choices and their reasons before scrolling through twelve files. Where another approach seemed more suitable, I would ask and revise. Where I agreed, the work could continue.
The meaningful difference would appear at lunchtime. Asked why the feature was built that way, I could describe the alternatives and the reason for the choice. The agent would have performed the implementation; the person would have set the criteria and participated in the decisions that needed them. I want to build products in which effective automation and human learning can happen in the same working day.
Notes
[1] Mathias Biilmann, Agent Experience moves upstream, Netlify, April 29, 2026. The initial proposal appeared in Introducing AX: Why Agent Experience Matters, January 28, 2025. ↩
[2] Anthropic, Introducing Citations on the Anthropic API, 2025. Referenced for its description of links between answers and source passages. ↩