The Bottleneck Moved

AI made building cheap. It made being wrong expensive.

A product manager wrote this in a 2026 industry survey, unprompted, in a free-text box:

Delivery of designs and code got very fast. Delivery of good decisions became the new bottleneck.

That sentence is the whole report. Product Circle and Product Institute's State of AI in Product 2026 asked 309 senior product people how AI had changed their work, and the headline isn't that adoption is coming — it's already here. 87.7% use AI coding assistants. 85.4% use AI for product work. 69.9% have shipped an AI-powered feature. The tools landed.

Then one number breaks ranks: only 36.1% say AI is actually strengthening how their team operates. Nearly a third say it's exposing weaknesses or making things worse.

The gap between "we adopted the tools" and "the tools made us better" is the entire story. Everything else in the report is detail.

The build layer outran the judgment layer

The survey splits AI's impact by where it lands, and the shape is stark. Engineering: 50.2%. Design: 45.3%. Then it falls off a cliff. Strategic planning: 17.5%. Cross-team collaboration: 9.3%.

The part of the work that produces code got radically faster. The part that decides which code is worth producing barely moved. The build layer is on a rocket. The judgment layer is still running on memory, meetings, docs, and vibes.

That asymmetry isn't a temporary lag that more tooling closes. It's structural. Coding assistants got good because code has ground truth — it compiles or it doesn't, the test passes or it fails, the loop is tight and the feedback is instant. Product judgment has none of that. Whether the feature was worth building shows up months later, tangled in a dozen other variables, and by then nobody can run the counterfactual. The thing that made the build layer easy to accelerate is exactly the thing the strategy layer doesn't have.

The economics inverted

Here's the line worth keeping:

AI made building cheaper, so bad prioritization got more expensive.

When building was the constraint, a wrong call cost you a sprint and got caught — you'd notice the team grinding on something that wasn't shipping. Building was the meter running, so building was where you watched.

Now the meter barely runs. An agent ships the wrong feature, cleanly, to the right file, in an afternoon. Nothing grinds. Nothing sounds an alarm. The cost didn't disappear; it moved upstream and went quiet. The expensive mistake is no longer "we built it slowly." It's "we built the wrong thing quickly, and again, and again, because the only thing that got cheaper was the part that was never the hard part."

Speed didn't relieve the judgment problem. It promoted it. When output is cheap, the decision about what to output is the only thing left that's expensive — and it's the one thing the tools in that 87.7% mostly leave untouched.

The honest part: a tool is not the answer the survey asks for

Steelman the other read, because the report itself leans that way. Its implied cure isn't "buy something." It's operating model, strategy translation, governance. The most quoted finding is a communication gap: 61.9% of PMs say there's no clear AI strategy, against 19.0% of C-level — a 42.9-point chasm between the people setting direction and the people who have to act on it. That reads like an org problem. Hire a Head of AI. Run the offsite. Write the strategy doc.

And only 19.0% described their pre-AI operating model as "mature and healthy" in the first place. AI didn't break these teams. It found them already broken and turned up the volume.

So the steelman is real: maybe the answer is process, not product. We won't pretend otherwise — a strategy nobody can act on is a worse problem than no tool, and we don't sell our way out of it. Context isn't judgment, and neither is software. We've said before that an intent tool can itself become part of the flood.

But "process, not product" has a hole in it. A strategy doc is judgment with no address — it lives in a slide deck the agent never reads, written in a clock and a vocabulary that drift apart by the next sprint. The 42.9-point gap isn't a writing failure. It's a plumbing failure: the decision was made somewhere it can't reach the work. Process decides what's worth building. It needs a place where that decision gets authored from evidence, made testable, and handed to the thing doing the building. Otherwise it's a meeting that already happened.

What actually tightens

The survey's most useful sentence isn't a complaint, it's a spec for the winners: the teams that pull ahead won't be the ones with the most AI usage. They'll be the ones whose decisions, evidence, constraints, and verification loops get tighter as output speed rises.

That's the whole job, and it's concrete. We've watched it on one task. Hand an agent "improve the checkout payment step" with only the architecture wired in and it improvises a plausible improvement — retry logic, placed perfectly, solving nothing. Hand it the why first — the abandonment evidence, the outcome the team is chasing, the boundary not to cross — and the plan changes before a line is written: a visible processing state by one second, recovery at three, no double charge, don't touch the provider flow. Same speed. Same agent. The difference is whether the reason was in the room.

That's what tightening looks like. Not slowing the build down — wiring the evidence, the outcome, and the verification into the build, so that going fast and going the right direction stop being a tradeoff. Pathmode is the product judgment layer: the place the decision gets authored from evidence and made testable, then served to the agent at plan time, so the cheap part runs toward something on purpose.

The bottleneck moved. It used to be how fast you could build; now it's whether you decided the right thing to build before the building got cheap enough to do it ten times.

The survey says most teams haven't moved the work to match the tools. The teams that win this won't be the ones typing the most into an agent. They'll be the ones whose judgment got tighter as their output got faster — because that's the only direction the expensive mistakes can come from now.

Source: "State of AI in Product 2026," co-published by Product Circle (Joao Moita, Sergiu Lazar) and Product Institute (Melissa Perri), released under CC BY-NC 4.0. Figures are cited as reported; the quoted line is reproduced for commentary.