Design taste is consistent judgement about what fits a purpose: which of many valid options to choose, what to leave out, and when something is finished. It shows in thousands of small decisions (a weight, a gap, a word) that add up to a coherent whole. In AI-generated interfaces, taste is exactly what’s missing by default, because a model without direction chooses the most likely option rather than the most fitting one.
A working definition
Definitions of taste range from innate gift to fashion. For practical work, a narrower one is more useful. Nielsen Norman Group’s article on taste and AI describes it as a series of decisions, from small visual details to large contextual choices, that contribute purposefully to a whole, and argues that it shows up as intentionality. We’d put it this way:
Taste is the ability to make choices that fit a purpose, consistently enough that the result feels like it came from one point of view.
Three parts of that matter:
- Choices: taste is selection and omission, not production. Anyone, and any model, can produce options.
- Fit: good taste for a trading terminal is bad taste for a children’s app. It’s relative to users and context.
- Consistency: one good decision is luck. Taste is the same judgement applied across a whole product.
What taste is made of
Taste can feel indefinable, but in interface work it breaks down into recognisable parts:
- Exposure: having seen enough good and bad work to recognise the difference.
- Vocabulary: being able to name what you see: density, rhythm, hierarchy, contrast, restraint.
- Principles: preferences you can state, such as “hierarchy through weight before size”.
- Restraint: knowing what not to add. Most generated UI fails here, not on missing features.
- Context: knowing who it’s for, which changes what “right” means.
How taste shows up in an interface
You rarely notice taste directly. You notice its effects:
- The most important thing on the screen is obviously the most important thing.
- Related things look related; unrelated things don’t.
- Every colour, icon and border is doing a job.
- The empty state, the error state and the long-name case feel as designed as the hero.
- It feels like this product, not a template.
Its absence is just as recognisable: the gradient hero, the three icon cards, the even spacing that groups nothing. We catalogue those defaults in why AI-generated interfaces look generic.
Why AI-generated interfaces lack it by default
A language model predicts likely output. Anthropic’s applied AI team describes the effect on interfaces as distributional convergence: without direction, models gravitate to the most common patterns. That’s close to the opposite of taste, which is about choosing what fits rather than what’s typical. The model has the capability; what it lacks is the point of view.
Can taste be written down?
Partly, and the part that can is the part agents need. Not every judgement survives being put into words, but a surprising amount does:
- References with reasons capture exposure: “this, for its density, not its colours”.
- Principles as prefer and avoid capture stated preferences.
- Counter-examples capture restraint.
- Context (who, what for) captures fit.
What can’t be written down is the final call on a specific screen. That stays with the designer, and it’s why review matters more, not less, when agents do the building. The practical method for turning taste into agent context is in how to give AI coding agents better design taste.
Taste is learnable
NN/g’s point that taste is intentionality makes it a practice rather than a gift. The same habits that make taste transferable to an agent also develop it in people: collecting work deliberately, naming what makes it good, writing principles and testing them against new screens. A design inspiration library built for retrieval is as much a training tool for a designer as it is context for an agent.
Writing taste down in Attuna
Attuna is built on this definition. In Attuna, in private beta, the parts of taste that can be written down live in a project: references tagged by what they demonstrate, rules to prefer and avoid, likes and dislikes. Coding agents read the project over MCP. The final call stays with you: rules an agent suggests aren’t used until you approve them.