AI can produce "good enough" at scale. What it can't produce without explicit instruction is good. The gap between the two is taste — and taste can be encoded.
The problem with vague instructions
Tell an agent to "make the animation feel natural" and you'll get a 200ms ease-in-out on everything. Technically animated. Feels like a template.
The agent doesn't know that ease-in is wrong for UI because it starts slow — the element accelerates at the end, giving the perception that the interface is lagging behind the user's action.
It doesn't know that 200ms is right for a dropdown but wrong for a modal. It doesn't know that a popover should scale from the trigger point, not from center. It doesn't know that the button needs scale(0.97) on :active, not scale(0.9), because 0.9 feels like the interface is collapsing.
It doesn't know because you didn't tell it. And you couldn't tell it because you hadn't articulated it yourself.
Taste is trainable, not innate
Taste isn't a personality trait. It's a trained instinct — the accumulated result of studying enough good work to recognize what separates it from adequate work.
The training loop has three steps:
Exposure: surround yourself with work at the highest level of craft. Use products that are exceptionally good, deliberately, not passively. With the question: what is this interface doing that I'm not noticing consciously but that makes me feel good?
Articulation: when something feels right or wrong, don't stop at "it feels off." Go to the specific property. The easing. The duration. The origin point. The stagger value. The reason it works is always findable — it may just require slowing down to 0.25x speed to see it.
Encoding: once you can articulate why, you can write the rule. Once you can write the rule, you can transfer it to an agent.
What a skill file looks like
This is a taste decision encoded as an agent instruction:
## Easing — Decision Flowchart
Is the element entering or exiting the viewport?
├── Yes → ease-out: cubic-bezier(0.16, 1, 0.3, 1)
└── No
├── Moving/morphing while already visible?
│ └── Yes → ease-in-out: cubic-bezier(0.87, 0, 0.13, 1)
└── Hover state change?
├── Color/background only → ease (built-in CSS is fine)
└── Constant motion (loader)?
├── Yes → linear
└── Default → ease-out
NEVER use ease-in for UI animations.## Duration — Hard Rules
| Element | Duration |
|---|---|
| Button press, scale on :active | 100–150ms |
| Tooltips, dropdowns, selects | 150–250ms |
| Modals, drawers, overlays | 200–300ms |
Hard limit: 300ms for any UI animation.
Keyboard-initiated actions: 0ms — never animate.
High-frequency interactions (>20×/session): 0ms — never animate.## Scale — Specific Values
Never animate from scale(0).
Correct initial values:
- Dialog/modal entrance: scale(0.95)
- Popover/dropdown: scale(0.95), origin from trigger
- Button :active feedback: scale(0.97)
- Toast entrance: translateY(100%)The agent that reads this produces correct output without guessing. The agent that receives "make it feel natural" produces a template.
A real example: building a taste transfer system
Over the past months I've been building a personal skill system for every web project I work on: a set of markdown files loaded into Cursor as context that encodes my design decisions as rules.
Four modules:
Motion — easing flowcharts, duration tables, clip-path techniques, when not to animate, the frequency test, GSAP timeline patterns.
Interaction — when to trigger during vs at gesture end, spatial consistency rules, feedback immediacy, interruptibility, the 8 principles of craft interaction.
Typography — ratio decision by project type, line-height by scale level, letter-spacing rules, tabular-nums for data, font loading without layout shift.
Code — HTML semantics, CSS property order, TypeScript patterns, GSAP readable timelines.
What changes
The value of a designer is no longer in executing decisions. Any agent can execute. The value is in making decisions that are correct and articulable enough to be replicated.
That requires deeper understanding of why something works, not just that it does. It requires building vocabulary for decisions that used to live only in intuition.
Every decision you articulate becomes a rule. Every rule becomes a constraint the agent works within. Every constraint eliminates a category of mediocrity from your output.
That's a higher bar than "I have good taste." It's a different skill. Taste as infrastructure, not taste as personality. And it compounds.