Taste Over AI: Why Judgment Beats Production

Every experienced designer I know has the same complaint about AI-generated creative work: it's technically fine and subtly wrong. The proportions are correct but the hierarchy is off. The image is sharp but the focal point communicates the wrong thing. The copy is grammatical but it lacks a point of view. The output resembles good work without being good work.

That gap - between resemblance and reality - is where taste lives. And it has become the most consequential skill in any field where AI tools have dramatically lowered the cost of production.

Production is no longer the bottleneck

Midjourney turns a paragraph into a finished image. Cursor turns a description into working code. Ideogram generates a dozen variations in the time it used to take to sketch one. The gap between having an idea and having something that represents that idea has compressed from days to seconds.

This helped a specific kind of person enormously. The developer who always had strong opinions about code architecture but hated writing boilerplate. The strategist who could articulate what a brand should feel like but couldn't execute the visual. The writer who understood exactly what argument they wanted to make but got stuck in the mechanics of structure. These people were bottlenecked by execution. Remove the execution bottleneck and their output improves dramatically.

But something else happens to people who were previously bottlenecked by not knowing what they wanted. Give them unlimited production capacity and they produce unlimited undifferentiated output. The tool generates. They approve or reject. Their approval criteria are vague. The results are fine. Just fine.

What taste actually is - not preference

Preference is easy. You like this font more than that one. You find this color combination appealing. You prefer shorter sentences. None of this is taste. Preference is just your reaction.

Taste is the ability to articulate why a specific choice serves the specific purpose it's meant to serve - and to recognize when it doesn't. A developer with taste can explain why this naming convention makes the code easier to maintain six months from now, why this abstraction creates flexibility where it's needed and coupling where it's acceptable, why this error message will help the next person debug the problem rather than obscure it. They can point to decisions and defend them with reasons that survive scrutiny.

This is what Claude or any other model cannot do on your behalf. A model can produce output that statistically resembles code that humans have praised. It can't know whether the reasons those humans praised it apply to your codebase, your team's conventions, or your specific maintenance requirements. That judgment has to live with a person who understands the context.

The same is true in any creative domain. A model generating marketing copy produces sentences that resemble effective marketing. It doesn't know whether the audience for your specific product has been over-marketed to in exactly this register, whether the current moment calls for a different tone, or whether the claim you're making is one your customers will find credible versus hollow. Those calls require someone who has thought carefully about the domain.

Situation	Preference response	Taste response
Reviewing AI-generated code	"This looks clean"	"This will be hard to test because the side effect is buried - move it here"
Reviewing AI-generated design	"I like the colors"	"The CTA is competing with the headline for visual weight - one of them needs to recede"
Reviewing AI-generated copy	"This reads well"	"This is technically accurate but the tone assumes familiarity the reader doesn't have yet"

Why taste atrophies if you're not deliberate about it

Taste develops through a specific process: you make something, you get feedback on whether it worked, you refine your intuitions about why, and you repeat. The friction in that loop - the cost of making, the sting of negative feedback, the effort of iteration - is not incidental to the learning. It's the mechanism.

Early photographers developed taste partly because film cost money. You got 36 exposures. You chose carefully. You looked at the results. You thought about what worked and why. You shot another roll. The constraint created attention.

Remove the constraint and people rarely replace the attention. They generate more. The feedback loop that builds taste - make, evaluate specifically, understand why, adjust - requires deliberate engagement that doesn't happen automatically when production is free.

Using Cursor or Claude to write your code without actively evaluating why certain outputs are better than others is efficient. It's also gradually transferring the judgment function to the model. The model's judgment is a statistical approximation of what has worked before. Your judgment, properly developed, is specific to your context and gets sharper over time. These are not equivalent, and treating them as equivalent is a skill atrophy risk.

The gap between competent and exceptional output

Two developers using the same AI tool with the same specification get different code. Not because of prompting tricks. Because one encodes judgment into the prompt and the other doesn't.

The developer with taste writes: "Write this function to be readable by a junior engineer six months from now, not to be clever. The hot path needs to be obvious from the top. Error cases should surface early with messages that include the actual values that caused the failure." They've encoded architectural opinions, readability priorities, and specific patterns into the direction before the model generates anything.

The developer without taste writes: "Write a function that does X." They use the first output.

The model does not compensate for vague direction by making smart choices. It makes choices that are statistically average for the space of valid outputs. Average is fine. The situations where fine is good enough are numerous. The situations where they're not - where the output will be used by someone with different context, read by someone who needs to maintain it, or evaluated by someone with high standards - are also numerous. Taste is what determines which situation you're in and acts accordingly.

An actionable challenge for this week

Pick one thing you're building right now - a feature, a piece of writing, a design - where you've been using AI to generate and mostly accepting what comes back.

Generate ten variations. Then do something different from what you normally do: for each one, write down specifically why it works or why it doesn't. Not "I like this" or "this feels off." Why it works. What decision the model made that serves the purpose, and what decision it made that doesn't.

This exercise does two things. First, it forces you to articulate the criteria you've been applying implicitly - which often reveals that you haven't actually been applying criteria, you've been following feeling. Second, it gives you material to encode into your next prompt, so the model generates from your actual requirements rather than statistical average.

Do this for two sessions on the same project. Notice whether your ability to articulate why something works improves. That improvement is taste developing. The tool handles infinite production. You handle judgment. Both matter; only one of them can be outsourced.