There's a word that keeps coming up when people talk about the best work in any field. Engineering, security, writing, even cooking. The word is taste. And most people have no idea what it actually means.
It's not about aesthetics. It's not about knowing which fonts are trendy. Taste is judgment. The ability to tell the difference between something that works and something that really works, and the refusal to settle for the former.
What taste actually is
Paul Graham wrote that taste is the ability to recognize good work. That's the simplest definition I've found, and it's exactly right. Taste is pattern recognition applied to quality. You look at a thousand things, and over time you develop an instinct for which ones are actually good versus which ones just seem good at first glance.
A programmer with taste knows when an abstraction is pulling its weight versus when it's just adding indirection. A security engineer with taste knows which threat models matter for their environment and which ones are theoretical noise. A writer with taste knows when a sentence is doing real work versus just filling space.
None of these people can always articulate why they know. That's what makes taste different from knowledge. Knowledge is "this pattern exists." Taste is "this is the wrong place to use it."
Why most people don't develop it
Taste requires exposure. You can't develop it in isolation. You need to see a lot of work. Good work, bad work, work that seemed good but aged poorly, work that seemed simple but turned out to be brilliant.
The problem is that most people consume passively. They scroll, they skim, they use things without thinking about why those things feel the way they do. Developing taste requires active engagement. You have to ask: why does this work? Why does that feel off? What would I change, and why?
The other problem is ego. Developing taste means admitting that your current work isn't as good as you thought it was. Every step up in taste is a step up in self-criticism. You start seeing flaws in things you were proud of yesterday. That's uncomfortable, and most people avoid discomfort.
Taste in engineering
In software, taste shows up in the decisions you don't make. The feature you don't add. The abstraction you don't create. The config option you don't expose.
Bad engineers add complexity because they can. They build flexible systems that flex in directions nobody ever needs. They add layers of abstraction for hypothetical future requirements that never arrive. They over-engineer because over-engineering feels like rigor.
Engineers with taste do the opposite. They look at a problem and ask: what's the simplest thing that could work here? Not the laziest, the simplest. There's a difference. Lazy is cutting corners. Simple is finding the solution with the fewest moving parts that still solves the actual problem.
I see this in security work all the time. The best security engineers don't build the most elaborate detection systems. They build the ones that actually catch real attacks. They know which threats are real for their stack and which ones are conference-talk material that'll never happen in their production environment. That's taste applied to risk.
Taste is opinionated
Here's the part that makes people uncomfortable: taste requires having opinions and being willing to defend them. You can't have taste and also be neutral about everything. "It depends" is sometimes the right answer, but if it's always your answer, you don't have taste. You have indecision.
The best products are opinionated. They make choices on behalf of the user. They don't expose every option because someone somewhere might want it. They decide what the right default is and ship that.
This is why building by committee produces mediocre work. Committees optimize for consensus. Taste optimizes for quality. These are often in conflict.
How to develop taste
There's no shortcut. But there is a process:
Look at a lot of work. Not just in your field. Read good writing, study well-architected systems, use products built by people who clearly gave a shit. Cross-pollination matters. The engineer who only reads code will write code that feels like code. The engineer who also reads good prose will write code that feels considered.
Copy things you admire. Not to claim as your own, but to understand them. Rewrite a function from an open source project you respect. Rebuild a tool you think is well-made. The act of reconstruction forces you to notice decisions you'd have missed as a user.
Get feedback from people with better taste than you. This is the hardest one because it requires finding those people and then being willing to hear that your work isn't as good as you thought. But it's the fastest accelerator. One honest critique from someone with great taste is worth more than a hundred "looks good to me" reviews.
Ship things and revisit them later. Your taste improves over time. Go back to projects you built six months ago. The cringe you feel is growth. If you look at old work and think it's perfect, your taste hasn't improved.
Delete more than you add. Every time you're about to add something, a feature, a config flag, another dependency, ask if the thing would be worse without it. Often the answer is no, it would actually be better. Removing the unnecessary is the purest expression of taste.
Taste is not talent
Talent is innate ability. Taste is cultivated judgment. You can be talented without taste. Plenty of skilled engineers write overcomplicated code. And you can have great taste without extraordinary talent. You just need enough skill to execute on your judgment.
The good news is that taste is learnable. It takes time, exposure, honesty, and a willingness to be wrong about what you thought was good.
The bad news is that once you develop it, you can never turn it off. You'll feel the weight of unnecessary dependencies in a package.json. You'll know when something was built by someone who cared versus someone who was just shipping tickets. You'll notice when a system was designed versus when it just happened.
But that's the point. The people who make things that last, things that people actually want to use, are the ones who couldn't stop noticing even if they wanted to.
Taste is what turns competence into craft.