I’ve been thinking about one word more than any other lately: taste.
It sounds like aesthetics. Like preference. Like vibes.
But I mean something much more concrete:
When AI pushes the cost of execution down, taste becomes the moat.
Because the gap is rarely “can you build it?” anymore. The gap is:
- Should this exist at all?
- What’s the one cut that matters first?
- Which “clever” feature will dull the product?
- Which scary constraint will keep the system alive longer?
Benchmarks don’t answer these questions. Your standards do.
Taste isn’t preference — it’s a filter
People often treat taste as subjective: “I like X, you like Y.”
I think of it as a stable filter you carry with you:
- You can separate signal from noise quickly.
- You can choose the more durable option among many “reasonable” ones.
- You’re suspicious of “more,” and excited by “less, but sharper.”
In other words, taste is a kind of direction-sense. And it’s rarely “talent.” It’s usually built from two long-running loops:
- Exposure: you’ve seen enough great work—and enough expensive mistakes.
- Consequences: you’ve shipped decisions and lived with the debt.
Taste isn’t an opinion. It’s a fast decision process.
Why taste becomes more valuable now
AI has done something very real in the last couple of years: it lowered the cost of turning ideas into outputs.
Code, copy, drafts, research, variations, scaffolding—work that used to require time and specialists now feels callable.
This is good news:
- iteration is cheaper
- small teams can explore more
- the “blank page” cost is dramatically lower
But it has a side effect: competence starts to look like a default.
When everyone can produce a decent first version quickly, advantage moves up the stack:
- from execution → selection
- from speed → direction
- from output → standards
That’s where taste lives.
A contrarian take: the benchmark winner might have the worst taste
This is my personal bias (and I might be wrong), but I increasingly believe it:
The best benchmark model is likely trained on the most data. But “taste” means being better than most people. So a model trained to fit the broadest distribution will often have the most average taste—which is to say, the weakest.
The mechanism is simple: large-scale training fits a distribution. The more data you fit, the closer you get to the mean.
And taste is often a deliberate deviation from the mean:
- restraint over coverage
- coherence over cleverness
- a point of view over maximal agreement
- a consistent set of constraints over “works for everyone”
If you optimize a model to be “correct for the most people,” the easiest output to produce is something you can’t really argue with—but also can’t remember: polished, safe, and slightly bland.
That matches a common experience: AI-generated content is often “pretty good,” but lacks sharpness. AI-generated design is often “credible,” but rarely has a signature.
Models can simulate taste via preference learning, prompting, personalization, and retrieval. But that often feels like “dialing a general model toward a style,” not having an intrinsic high-standard preference function.
Here’s the blunt version:
Taste isn’t knowledge. Taste is a rejection list.
And rejection means giving up coverage, giving up approval, giving up the average.
A counterpoint: taste is also a data and alignment problem
A friend pushed back on the contrarian take above with a useful nuance: "best on benchmarks" does not always mean "most data." It can also mean "saw more of the test distribution," sometimes literally via contamination. That does not explain everything, but it is a real confound.
From that lens, taste has at least three levers:
- Pretraining: taste is data curation. More high-quality data and less junk produces a clearer internal standard.
- Post-training: taste is alignment. The people who write preferences (and the reward model built from them) decide what "good" sounds like; strong literary preference data can make a model feel far more refined (DeepSeekV3's writing is a good example).
- Self-play or environment-driven RL (RLVR): a model can evolve a preference function that is not human at all, the way AlphaZero found strategies no human would invent.
One more implication: because mainstream models are aligned to be helpful and human-pleasing, they tend to amplify human taste in production. You only see "model-native" taste when an agent runs long enough to develop its own goals and internal standards.
This does not contradict the mean-regression argument. It just adds an extra axis: data quality and alignment decide which mean you converge to, and whether you can escape it.
Taste shows up in what you don’t do
When you look closely at products, systems, or even writing, taste rarely appears as “inventing a new feature.” It appears as “holding a standard.”
It shows up in unsexy decisions that are easy to misunderstand:
- killing an acquisition hook that degrades the experience
- replacing a “smart” automation with a simpler, explainable workflow
- leaving whitespace, leaving edges, leaving room for the user to breathe
- moving slower so you don’t push the system into irreversible complexity
These choices are hard to “prove” in a single sentence. But over time they split outcomes into two very different endpoints:
- something everyone can use, but nobody loves
- something narrower, but memorable enough that users share it for you
The cost of taste: you have to give up what you could have
Taste is scarce for a practical reason: it always has opportunity cost.
When you make a real trade-off, you’re not “optimizing.” You’re choosing to forgo:
- broader coverage (because you hold a narrower standard)
- easier approval (because you won’t round off the edges of your point of view)
- the safest path (because you know it leads to the same generic flavor)
Many people don’t lack taste because they don’t know better. They lack taste because they can’t pay this cost.
This is why two people with the same AI tools—and the same ability to ship prototypes fast—can end up with wildly different results. The difference isn’t productivity. It’s courage and standards.
Taste isn’t style — it’s structure
It’s easy to confuse taste with style: typography, color, tone, word choice. Those matter—but they’re surface.
The taste I care about is structural:
- does this interaction reduce cognitive load by one step?
- will this information architecture still stand when the product doubles in size?
- does this abstraction make future changes easier, or harder?
- do the defaults express what you actually believe?
When you move taste into structure, it stops being “aesthetic” and becomes “engineering”: using limited resources to build something that stays good as it ages.
Taste is a trained reward function
If I borrow an engineering metaphor, taste is like a loss function (or a reward model) you internalize.
It decides what you reward when there are infinite valid solutions:
- do you reward “more,” or “precise”?
- do you reward “familiar,” or “new”?
- do you reward short-term metrics, or long-term structure?
People with taste aren’t necessarily better at producing. They’re better at evaluating. They can quickly tell:
- is this just fancy, or actually better?
- is this a shortcut that creates technical debt or cognitive debt?
- is 80% enough here, or does this need to be 95% to matter?
AI can help you go from 0 to 70 faster. But going from 70 to 90 is rarely “do more.” It’s usually “delete half.”
Training taste with AI: make it generate more, make yourself delete more
If AI’s strength is generation, my suggestion is to treat it as a variation engine, not a “truth machine.”
A small practice that works well for me: force AI to give me 10 options at once, then I do only two things:
- Pick one I’m willing to be accountable for.
- Write down why the other nine are wrong.
It looks wasteful, but it trains taste quickly, because you’re forced to translate “this feels off” into “this is off because X.” When you can reliably say “I reject this because…,” taste becomes a skill instead of a vibe.
Another use I like: let AI play the contrarian reviewer.
- If I insist on deleting a feature, have it write the strongest argument for shipping it.
- If I insist on going narrow, have it list the real-world benefits of going broad.
You’re not doing this to get convinced. You’re doing it to verify: are your trade-offs deliberate, or just stubborn?
How I try to build taste (a practical loop)
The most effective approach I’ve found is surprisingly unromantic: treat taste like a system you train, not something you “develop naturally.”
I break it into four actions:
- High-quality input: only study things you’d re-read or re-use. Less scrolling, more deep looking.
- High-frequency output: ship small artifacts, so your judgments become visible choices.
- Review via comparison: regularly ask “if I did this again, what would I delete? what would I push harder?”
- An external editor: find a person or a body of work that functions as your reference standard.
AI is useful in this loop—as a sparring partner, a mirror, and a fast comparison set.
But I try not to let AI be the final judge. The moment you outsource the judge, your taste stops growing—it just gets replaced.
If you want something more concrete, I recommend building your own “taste dataset”:
- collect ~20 examples that make you think “this is it” (products, essays, pages, components, interactions)
- write one sentence for each: what’s great here, and what part is worth learning?
- before starting new work, skim this set to remind yourself what “good” means to you
It’s like a hand-made recommender system. The point isn’t collecting—it’s writing down reasons. The clearer your reasons, the more reusable your taste becomes.
Closing thought: let AI do the labor, keep the standards human
The best division of labor I’ve found in the AI era looks like this:
- AI turns ideas into discussable prototypes and reduces mechanical effort.
- You set the bar, make the cuts, define the edges—the taste part.
When execution is cheap, the scarce resource becomes “what’s worth executing.”
Taste is the thing that compresses “many correct options” into “one that feels inevitable.”