For the last ten years, the most reliable piece of advice I gave my mentees was a cliché: ideas are cheap, execution is everything.
It was true. In software engineering, the gap between a good idea and a shipped product was enormous. You had to write boilerplate, debug obscure errors, argue over architecture, and grind through edge cases for months. The people who won were the ones who could put their heads down and ship. The idea was just the starting line. The execution was the marathon.
But in the last two years, something fundamental changed. AI made execution cheaper than ideas.
So what do I tell them now?
To answer that, we have to look at what we actually meant when we said “execution.” We meant two things bundled together: throughput and judgment. Throughput is the raw volume of typing, coding, and building. Judgment is knowing what to type, code, and build.
We never distinguished between the two because they always came together. The person who knew what to build was usually the same person who had to build it. But AI has unbundled them. It has driven the cost of throughput toward zero while leaving the cost of judgment untouched.
Anyone can now spin up a studio of agents to write code, draft copy, or run A/B tests. A junior engineer can generate in an afternoon what used to take a senior team a month. When throughput is infinite, throughput is no longer a moat. If your value proposition is “I can build things fast,” you are competing against a rising tide that will only get higher. You will drown.
When everyone can execute, the bottleneck shifts from how to build it to what to build.
The word for knowing what to build is taste.
People usually think of taste as an aesthetic thing — picking the right font, the right color palette, the right animation curve. But in software, taste is structural. It’s the instinct that tells you not just what can be done, but what should be done. It’s the ability to look at a complex problem and see the elegant, simple solution hiding inside it. It’s knowing which features to leave out.
Think of a fashion house. Karl Lagerfeld wasn’t sewing every stitch at Chanel. The execution was handled by a team of highly skilled artisans. What people paid for was the creative direction. The taste. The name on the label meant that someone with exceptional judgment had decided this specific arrangement of fabric was worth existing.
We are entering the fashion house era of software. AI gives everyone a studio full of people to execute on their ideas. The cost of execution has collapsed, but the returns to taste and point of view have gone way up.
Why is taste so hard for AI? Because AI is incredible at synthesizing patterns across millions of data points. It can run a playbook perfectly. But it can’t write the playbook.
It can’t sit in a room with a frustrated user and notice the thing they aren’t saying. It can’t feel the specific anxiety of a decision-maker who knows the status quo is failing but is terrified of being blamed for what comes next. It can’t look at a product and feel, in its gut, that something is off — even when every metric says things are fine. Taste comes from lived experience, from friction, from being embedded in the messy reality of human problems. That asymmetry — between what AI can process and what only human presence can accumulate — is where differentiation now lives.
If taste is the new bottleneck, the obvious question is: can you develop it?
I think you can. It’s not magic. It’s a practice.
I’ve noticed that the engineers with the best taste tend to read a lot of things that have nothing to do with engineering. They read history, design, psychology, architecture. The best product instincts come from cross-pollination — from importing mental models that nobody else in the room has. If you only read Hacker News, you will only build things that look like they belong on Hacker News.
They spend time with users, not just dashboards. AI can analyze usage data better than any human. But only you can sit across from someone and watch their face when they hit a confusing screen. Taste is built from accumulated human friction, not from metrics.
They study the work they admire and ask why it’s good. They don’t just use great products — they reverse-engineer the decisions behind them. Why did this team cut that feature? Why does this interface feel effortless while that one feels exhausting? Taste is pattern recognition, and pattern recognition requires a large training set.
And most importantly, they have strong opinions and let them be wrong. Taste develops through judgment, and judgment develops through making calls and learning from the misses. People who hedge everything develop no taste at all.
We are about to drown in a sea of perfectly executed, perfectly average software. Every app will work. Every interface will be polished. Every codebase will be clean. And none of it will matter, because none of it will be different.
So what do I tell my mentees now? I tell them to stop optimizing for throughput. Stop trying to be the fastest typist. Start reading more, observing more, and developing a point of view about what good looks like.
The engineers who win the next decade won’t be the ones who can execute the fastest. They’ll be the ones with the taste to know what is worth executing in the first place. Ideas aren’t cheap anymore. Good ones are the only thing that matters.
