Your agent can't see your taste until it's readable

I watched an agent rebuild my landing hero last week. Same brief, three sessions, three different button styles. Not wrong, just not mine.

I have written that your AI agent has no memory and context files are the fix — agents start cold. Your taste is the same. If it lives only in your head, the agent fills the gap with the internet's median.

Your agent doesn't have taste. It reads taste. If you don't make it readable, it guesses.

Why can't agents see your taste?

Because taste isn't a picture. It's a set of choices you repeat without thinking.

An agent looking at a screenshot sees pixels, not rules. It can't tell if that 12px radius was intent or accident. So it copies the look and invents the rest.

Figma's guide to the Figma MCP server makes this explicit: agents get structure — components, variables, auto layout — not images. When the structure is missing, they generate React that looks right and codes wrong. Solo founders who ship consistent work remove what the agent has to guess at.

What does machine-readable taste actually look like?

It's shorter than you think.

My file is 47 lines. It fits on one screen and an agent reads it in one pass:

Tokens, not adjectives. 8px base, 10px card radius, 6px control radius. Inter 14/20 for body, Newsreader for display. Text zinc-950 on white, white on zinc-900.

Components, not suggestions. Six buttons, two cards, one input. "Never invent a new button. Use Button from /components/ui."

Nevers as rules. Never use thin icons. Never use gradients for buttons. Never invent a shadow — use shadow-sm or none.

Links, not pastes. Figma file, tokens.json, and a preview page. One source of truth, not a stale copy.

That's testable taste. "Make it feel premium" can't be checked, so it doesn't belong. Anthropic's guide to building effective agents says the same: give the model the right context and constraints, then keep the loop tight.

How do you wire taste into Figma and code?

You connect the design piece and the code piece so the agent doesn't have to map them.

First, lock the Figma side. Use variables for color, spacing, type, and radius. Name layers like PricingCard, not Group 23. Use auto layout so responsive intent survives. That is what the MCP server sends — not the canvas image, but the structure.

Second, map it to code. Figma's measured results with Code Connect in MCP show the payoff: across 27 tasks, median duration fell 19.6%, token use fell 29.5%, and code quality rose a full point because the agent imported the real component instead of hand-building a fake. Without mapping, it looked close and failed — tabs that didn't switch, padding off by 2px.

Setup takes an afternoon: publish your library, connect components to code, point your agent at the MCP server. The agent then gets real snippets — import { Button } from '@/components/ui/button' — instead of invented divs. Your taste file stays small because the system holds the rules.

Third, keep the taste file in the repo. Reference the Figma file and tokens, don't duplicate them. Version it like code. Changed a radius but didn't commit? You didn't change it.

When does this still fail?

When you let taste cover everything.

Don't encode curation. The file holds what good looks like so you can judge faster. It doesn't pick for you. I keep the edit on three checks:

Is the primary action obvious without reading? If the eye lands elsewhere, hierarchy broke. Fix the slot, not the prompt.

Does the same thing look the same on page two? Consistency is trust. One button that shifts weight between pages costs more than polishing a hero.

Can you recover without help text? Empty state, failed generation, no permission — if the user can't act, the problem isn't taste. It's the flow.

Let agents propose inside those checks. Keep approvals, memory scope, and what gets forgotten as human calls. That's the split I argued in AI is for the plumbing, not the judgment — automate the repeatable parts, keep the calls that need a point of view.

Start narrow. Write 40 lines of nevers. Connect five components. Build one empty state in a fresh session. Under ten minutes and it feels like you? The system is readable. Over an hour? Thin the file, name a variable, map one more component.

Taste that lives in files outlasts a chat window.