Taste is suddenly everywhere. It has clearly touched a nerve. Everyone seems to have an opinion, but most of the conversation focuses on how things look.
But what happens when the user has no eyes?
Yes, I’m talking about AI agents.
Calling agents a user might sound premature to some, but for most developer tools out there, this is their reality. Check this graph.
And there are plenty of examples like this.
For these companies, agents are not only the main interface humans use to interact with their product, but their main acquisition channel. An agent suggests the product and performs tasks under human command.
My bet is that within the next eighteen months, most companies will serve two users: the human who wants the outcome and the agent that performs the work.
If your company exposes an API, agents will consume it. If it doesn’t, hopefully someone will eventually build an adapter around you. Otherwise, you are cooked.
Okay, now consider what that means for taste.
Imagine a human wants to add payments to an application. A year ago, they might have searched for solutions, read docs, and joined Discord communities to evaluate a provider and understand how to implement it.
Now they may simply prompt an agent.
The agent proposes a solution and starts performing the task programmatically. What happens next is what’s interesting.
The agent hits its first error:
Which parameter? Why is it invalid? What values are accepted?
Not enough context for the agent to understand what failed, so it guessed the next step. The whole run becomes a series of trial-and-error cycles. The cost is paid in wasted tokens, increased latency, weak workarounds, and sometimes silent churn.
Compare that with an error message that identifies the field, explains the constraint, links to relevant documentation, and says what to try next.
That is not cosmetic polish. That is product taste in the agentic era.
Sarah Guo’s essay on taste makes the important point that quality runs deeper than pixels. Stripe’s plain English error messages are the perfect example.
But the agent changes why that decision matters.
A human appreciated a clear error, the agent recovers because of it.
An agent has no sense to please. It won’t feel your demo, notice your hover states, or cringe at an ugly button. It won’t even notice. That doesn’t make it taste blind.
The agent does not admire your good defaults. It will simply succeed more often when you have them. That’s a tasteful experience.
For an agent, taste lives in seemingly boring places: conventional names, typed schemas, stable response shapes, idempotent operations, useful defaults, and errors that identify both the cause and the recovery path.
Taste is crafting with intention. It’s the relentless, almost painful ability to know what should exist, what shouldn’t, and where quality matters.
Human-facing taste often begins with empathy. You watch someone hesitate. You hear frustration in their voice. You notice the moment they lose trust.
An agent gives you none of that. It does not wince, complain, file a bug, or write a tweet about your error message. It retries. It patches around your surfaces. Or it switches to a competitor between two tool calls and never tells you why.
Taste for agents has to be earned in a different way.
You cannot capture an agent’s expressions or feelings, but you can watch its trace: where it stalls, which errors trigger retries, what it gives up on, which workaround it invents, and whether it chooses you again.
This is why taste for agents is rare. The decisions that matter are often invisible to humans, and success looks like nothing happened: the tool was selected, the call worked, and the task continued.
The agent will never tell you that your product has taste. It will just succeed and choose you again.