Taste is the hardest skill to teach

I can teach someone React in a few months. I can teach them TypeScript, database design, deployment pipelines. These are systems with rules, and rules can be learned.

What I can't teach quickly is taste. That instinct that tells you a button should be 2 pixels smaller, or that a transition is 100 milliseconds too slow, or that a feature sounds good on paper but will confuse real users.

Taste is the filter between "technically correct" and "actually good." And it's the thing that separates products people tolerate from products people love.

What taste looks like in practice

It's not about aesthetic preferences. It's about decisions.

A developer with taste doesn't just build the feature that was requested. They think about whether the feature belongs in the product at all. They consider how it interacts with existing features, whether it adds complexity that isn't justified, and what the user will actually experience when they encounter it.

A designer with taste doesn't just make things look pretty. They understand information hierarchy instinctively. They know that adding one more option to a menu makes the whole menu worse. They feel when a layout is off-balance even if they can't immediately articulate why.

Taste shows up in the small decisions. Choosing to use a subtle animation instead of a flashy one. Deciding not to build a feature even though you already designed it. Picking the slightly less clever but more readable approach to a problem.

How taste develops

I don't think taste is innate. But I do think it develops through exposure and attention rather than through study.

You develop taste by using a lot of products. Not just the ones in your space, but products across every category. Use the best note-taking app and the worst one. Use a beautifully designed banking app and a terrible government website. The contrast teaches you more than any design course.

You develop taste by noticing details. When something feels good in an app, stop and figure out why. Is it the transition speed? The copy? The way the empty state guides you? Pull apart the experience until you understand the craft behind it.

You develop taste by building things and being honest about the result. Ship something, use it yourself for a week, and pay attention to what bugs you. The things that bug you are your taste trying to tell you something.

The danger of too much taste

There's a failure mode where taste becomes perfectionism. You know exactly what good looks like, and nothing you build meets that standard, so you never ship.

I've been stuck in this loop many times. Redesigning the same screen for the third time because something feels slightly off. Refactoring code that works fine because it's not elegant enough. Spending an hour on a gradient that 90% of users will never notice.

The trick is knowing when taste is serving the product and when it's serving your ego. If the improvement matters to the user, it's taste. If it only matters to you, it might be procrastination dressed up as craft.

Ship the thing that's 85% right. You can refine later, and you'll probably have better taste by then anyway.

Surrounding yourself with taste

The fastest way to develop taste is to spend time around people who have it. Watch how they make decisions. Pay attention to what they notice that you don't.

In the early years of my career, I worked with a designer who would look at my layouts and immediately spot things I'd missed. Not technical issues. Subtle things like "this section feels heavier than it should" or "the flow here breaks the user's mental model." At first these comments felt vague. Over time, I started seeing the same things before he pointed them out.

Code review works the same way. Reading code written by someone with taste teaches you patterns and sensibilities that no tutorial covers. It's not about their framework choices or architecture decisions. It's about the thousand small choices that make code feel considered rather than just functional.

Why this matters more than ever

AI can write working code. It can generate decent designs. It can produce technically correct solutions to most problems.

What AI consistently misses is taste. It doesn't know that a loading spinner in this specific context feels wrong and a skeleton screen would be better. It doesn't know that this particular user base finds playful microcopy charming but would be annoyed by it in error messages. It doesn't feel the rhythm of a well-paced onboarding flow.

As AI handles more of the technical execution, taste becomes the differentiator. The ability to look at something that works and know what would make it feel right. That's a human skill, and it's becoming more valuable, not less.