Ask a model for a dashboard layout and it will give you twelve, each one competent, none of them obviously wrong, and all of them looking suspiciously like they shipped from the same product. That used to be the hard part. A single competent option took a junior designer an afternoon. Now the bottleneck has moved, and almost nobody has updated their sense of where it went.
It moved to the choosing. Generating options was never the scarce skill, it just used to be slow enough that scarcity and slowness looked like the same thing. Take the slowness away and what is left is the actual constraint: recognizing which of the twelve is right, for reasons that have nothing to do with any single one of them being broken.
Taste is not a preference, it's a compressed history
The word gets used like it means "what someone happens to like," which makes it sound arbitrary, which is exactly backwards. Good taste in a domain is a compressed record of everything that person has looked at closely and formed an opinion about: the interfaces that felt cheap despite doing everything right on paper, the type pairing that looked fine in isolation and fought on the page, the version of a brand that photographed well and meant nothing.
None of that is in a model's weights as judgment. It's in there as pattern, which is a different thing wearing the same clothes. A model has seen more design than any person ever will and has opinions about none of it, because it has never had to live with a decision, watch it fail, and carry that forward into the next one. Taste is judgment with scar tissue. A model has the judgment's shape without the scars.
Why this is easy to miss right now
The reason this is a live confusion rather than an obvious one is that current output is good enough to pass a glance. Five years ago, a bad design decision from a tool looked bad, and the gap was easy to see. Now the twelfth option in a batch of generated screens can be objectively well executed and still be the wrong choice for this product, and nothing about how it looks tells you that. Competence and rightness used to travel together closely enough that checking one was a decent proxy for the other. They've come apart, and most of the frustration with AI-generated work is people still checking the proxy.
What taste actually does in a room full of good options
I've started paying attention to what I'm actually doing in the moment I reject eleven out of twelve options, because it's a strange kind of decision to introspect on. It doesn't feel like applying a rule. It feels closer to recognition: this one is wrong the way a note is wrong in a chord, immediately and without a checklist.
But there is a checklist underneath it, even if it doesn't run consciously. Does this cohere with the four decisions we already made and can't easily unmake? Does it read as considered or as generic, and if I can't say why, is that because there's no real difference or because I haven't looked closely enough yet? Would this still look right in the one context that actually matters, not the context it was generated to look good in? A model answering "make it look premium" is optimizing for a genre. Taste is checking whether the genre fits the actual thing, which the request never specified because the person asking assumed it was obvious.
The move that looks like taste and isn't
There's a failure mode that borrows taste's clothes: rejecting things because they don't look like what you'd have made yourself. That's not discernment, it's a mirror, and it's a worse filter than no filter at all, because it kills good ideas that happen to arrive from an unfamiliar direction along with the actually-wrong ones.
The honest version of the checklist above doesn't ask "is this how I'd have done it." It asks whether the thing is right on its own terms. That distinction matters more with a model than with a junior colleague, because a model will generate options you would genuinely never have arrived at yourself, some of which are better for exactly that reason, and a taste that only recognizes its own fingerprints will reject the best ones by mistake.
Taste doesn't transfer by watching, it transfers by deciding
The uncomfortable implication is that taste is not really teachable by exposure alone. Looking at a thousand good interfaces builds a library, and a library is not judgment, it's raw material for it. Judgment gets built by making a call, watching what happens when it's wrong, and updating, over and over, on real stakes. That loop is slow and it doesn't have a shortcut, and it's exactly the loop that's easiest to skip when a model can generate a plausible-looking answer faster than you can form your own opinion about the question.
This is where I've had to be deliberate rather than efficient. The tempting workflow is to generate first and react to what comes back, because reacting is easier than originating. But reacting to twelve options exercises a much shallower kind of judgment than starting from a blank page and forming a point of view before anything gets generated at all. I've started sketching a rough opinion first, on paper or in a sentence, specifically so the model's output gets checked against something I actually thought, rather than becoming the thing I think by default because it arrived first and looked finished.
What this means for the actual work
Practically, three habits have come out of taking this seriously.
Form the opinion before the generation, not after. A rough point of view, stated before you see any options, is the only thing that lets you tell the difference between "I chose this" and "this was the first plausible thing I saw."
Spend the time saved on comparison, not on quantity. The instinct with a fast tool is to generate more. The better use of the time a model saves is looking harder at fewer options, which is the part that was always scarce and is now the only scarce part left.
Practice taste on stakes that are real, even small ones. A decision that has no consequence teaches nothing, because there's no feedback loop to update the judgment. Pick something you'll actually ship and be wrong about sometimes, on purpose, in a low-cost setting, because that's the only place taste gets built.
None of this is an argument against the tools. It's an argument for noticing what they actually changed, which is not whether good work gets made, but who's responsible for recognizing it. That responsibility was never going to be automatable, because it's the same judgment layer I've written about elsewhere: the part that has to already know what right looks like before it can tell the model it got it wrong.