Product Judgment Used to Live in Your Head. That No Longer Scales.

In 2020, Paul Adams wrote what is still the definitive piece on product judgment. Product judgment, he wrote, is the ability to predict what your customers need and ship the right solution for them. And there is exactly one way to build it. Talk to hundreds of customers. He'd done around 500 interviews at one company, 800 at another. The judgment lived in his head, earned one conversation at a time.

He was right. He's still right about how judgment is built. What the AI era changed isn't how you build judgment. It's what now has to happen to it once you have it.

That essay described a world where the hard part of software was building it. You carried judgment in your head, and then you spent six months and a team of engineers turning a sliver of it into a shipped product. Execution was the bottleneck. Judgment was the cheap input: the part that fit comfortably inside one experienced person's intuition, dispensed in standups and design reviews as the work unfolded.

That world is gone.

When building gets cheap, choosing gets expensive.

The bottleneck moved

The evidence is no longer anecdotal. A 2026 NBER study followed more than 100,000 developers who adopted AI coding tools; with the most autonomous of them, commits jumped 180%, and total usage of everything they shipped stayed flat. More code, more releases, the same number of people who cared. We pulled that thread in The Cost of Being Worth Using. And when a survey of 309 product leaders asked what AI changed about their work, one of them wrote the whole story in a sentence: delivery of code got fast; delivery of good decisions became the new constraint. That's The Bottleneck Moved. The same survey shows where the acceleration landed, and where it didn't: AI's impact rated high in engineering (50%) and design (45%), and barely registered in strategic planning (18%), discovery, or customer feedback loops (13%). It made the building faster and left the deciding exactly where it was.

Strip it down and you get a simple inversion. For thirty years, the bottleneck in software was the ability to build it. Judgment mattered, but it was rarely the rate limiter. You could afford to be a little wrong, because being right took just as long to ship anyway.

Now an agent can build the feature in the time it takes you to describe it. The cost of execution fell through the floor. The cost of being wrong did not. Ship the wrong thing now and you've simply been wrong faster, at scale, with confidence. The constraint is no longer can we build it. It's should we, and is this the right "it."

That question has a name. It's product judgment. And it just became the most expensive thing in the building.

The problem Adams's era never had to solve

The 2020 framing never had to account for one thing, because it couldn't have.

In a world where humans execute, judgment-in-your-head works fine. The person with the judgment is in the room. They wrote the brief, they're in the standup, they answer the hundred small questions that come up mid-build: no, not that edge case; yes, ship without that; actually the real problem is upstream. The spec is a starting point; the judgment fills the gaps in real time, conversationally, because the human holding it is right there.

An agent is not in the room. It cannot read your instincts. You hand it a brief and it executes, completely, immediately, and exactly as wrong as your brief was thin. There is no mid-build standup where your taste quietly corrects the trajectory. Whatever judgment didn't make it into the words is judgment the agent never had.

So the thing that was a feature for thirty years (that good judgment could stay tacit, living in an experienced head and leaking out as needed) is now a bug. Tacit judgment doesn't delegate to a machine.

An agent with perfect context and no judgment builds the wrong thing, fast. Context isn't judgment.

This is the shift. Product judgment used to be something you had. Now it's an artifact you have to produce: explicit enough that something which was never in the room can act on it, and durable enough that it survives the handoff. The judgment has to leave your head. What problem, for whom, on what evidence, with which outcome, and what must not break in the process.

What good and bad product judgment look like now

Bad product judgment, in the AI era, is a brief that assumes a human will fill the gaps. "Improve onboarding." "Make checkout faster." "Add AI to the dashboard." Hand any of these to an agent and it will confidently invent the missing judgment: pick a problem you didn't mean, optimize a metric you don't care about, touch code you wanted left alone. Not because the agent is bad. Because you delegated the execution and kept the judgment.

Good product judgment is legible to someone, or something, that wasn't in your head:

Users abandon onboarding at the address step (35% drop, funnel + 6 of 8 usability sessions). Collapse the six fields to one type-ahead; cut step-three drop-off by at least 40%. Don't touch the OAuth provider. If the geocoder is down, fall back to the manual form. Confirm with an integration test and watch the drop-off rate for two weeks.

Same instinct. The difference is that the second one carries the why (evidence), the what (a measurable outcome), and the fence (constraints and edge cases), so the decision can be executed by an agent and reviewed by a teammate without either of them having to have lived your last three customer calls. That's not more bureaucracy. It's the same judgment, made explicit so it can scale past the one person who holds it.

Judgment vs. sense vs. intuition vs. taste

These four blur together, and the distinction matters more now than it used to.

Product intuition, product sense, product taste all name the same instinct: the fast, pattern-matched read that tells an experienced person this is the real problem, that feature is a distraction. This is what Adams was teaching you to build, and what Kahneman popularized as System 1: fast, intuitive, and sharpened over thousands of reps. It is real, it is valuable, and it still only comes from contact with customers.

Product judgment is what happens when that instinct meets a decision: which problem is worth solving, framed how, with what accepted trade-offs. Sense is the input; judgment is the applied call.

For thirty years the gap between the two didn't matter much, because the same person did both: felt the instinct and made the call, in their head, in the room. The AI era pries them apart. The instinct stays inside you. The decision has to come out, in a form an agent can act on. Taste you can't articulate is just preference. Taste backed by evidence and made explicit is judgment you can ship.

You can't keep it in your head anymore

If product judgment is now the limiting input and it has to leave your head to be useful, then "develop better judgment" is necessary but no longer sufficient. You also have to capture it, reliably, every time, before it evaporates into a Slack thread or a decision nobody wrote down.

That's a discipline, not a vibe. It has four moving parts:

• Evidence: the friction, quotes, and metrics the decision rests on, linked, not remembered.
• Intent: the objective and the observable outcomes, stated so "done" is unambiguous.
• Constraints and scope: the hard boundaries and the fence around what to leave alone.
• Verification: how you'll know it worked, before and after it ships.

Run a decision through those and the judgment stops living in your head. It becomes a durable, evidence-backed artifact, one an AI agent can execute against and a reviewer can argue with. We call that discipline intent engineering: turning product judgment under evidence into something an agent can act on without guessing. Judgment is the why; intent engineering is how you make it survive contact with a machine.

The job that's left

AI will keep getting better at execution. That curve only goes one way. Models can already propose, rank, and simulate. What they cannot do is be accountable for the call: own the decision, carry its consequences, or resolve the user-and-business trade-offs without judgment supplied from outside. That accountability is product judgment, and as execution approaches free, it's the part of the job that's actually the job.

Adams was right that you build judgment by talking to customers. That hasn't changed and it won't. What changed is that having it is no longer enough. In a world where the thing gets built the moment you describe it, the judgment that stays trapped in your head is judgment the product never gets. The work now is to get it out of your head and into the hands of whatever does the building. Evidence-backed, explicit, durable.

Building got cheap. Judgment is the job. Don't leave it in your head.