The Scarcity Shift: AI made building software faster. Now the harder question is deciding what's worth building.
Last year, one of Andrew Ng's teams brought him a staffing proposal that would have sounded absurd five years ago. Instead of the usual one product manager for every four engineers, they wanted two PMs for every engineer.
This would have meant that more people were deciding what to build than people building it.
Now, the PMs hadn't gotten slower; the engineers had just gotten faster. A lot faster. Ng's diagnosis was blunt: with AI writing much of the code, product management had become the bottleneck.
For decades, engineering capacity was one of the biggest constraints in product development. AI is changing that. But removing one bottleneck doesn't mean the entire organization suddenly moves faster. It means the bottleneck moves somewhere else.
The implication is bigger than a change in engineering productivity. When the ability to build stops being the limiting factor, the ability to make good product decisions becomes a much bigger determinant of how quickly an organization can create value.
In our last post, we argued that AI didn't eliminate scarcity in software; it just moved it. This post follows it to where it went.
When production stops being the bottleneck
Imagine a newsroom that suddenly gets a printing press ten times faster than before.
Previously, getting the newspaper printed on time was a constant struggle. Now the press can churn out pages faster than anyone imagined.
Problem solved, right? Not quite.
The editors are suddenly overwhelmed. Stories are arriving faster than they can be reviewed and fact-checked. So the newsroom hires more editors, improves its processes, and gets the production line moving again.
But the faster printing press hasn't solved another problem.
Which stories are actually worth publishing?
Which ones matter to readers? Which deserve further investigation? Which stories will make people choose this newspaper over another?
The printing press can produce almost anything the newsroom gives it. But it can't tell the editors what deserves to be on the front page.
Similarly, we're starting to see something like this in software development.
In its 2025 AI Productivity Paradox research, Faros AI analyzed engineering activity across more than 10,000 developers. Teams with high AI adoption merged 98% more pull requests, but pull-request review times were 91% longer.
Developers produced more code, but the review process didn't keep pace. And those individual productivity gains weren't translating into comparable improvements at the company level.
That's the first bottleneck shift: code generation accelerates, and the work starts piling up elsewhere. It's tempting to solve that by making code reviews faster too. And we should.
But I think there's a bigger shift happening further upstream.
The bottleneck is moving up the decision stack
Every product organization answers four questions, over and over, at four altitudes. Together, these decisions shape product prioritization, from determining what to own to deciding what to build next:
1. What should we own at all? Allocation: Deciding which capabilities belong inside our product and which are better provided by partners or platforms.
2. Which problems are worth solving? Problem selection: Understanding customer needs, identifying opportunities, and determining where solving a problem will create meaningful value.
3. What do we build next? Prioritization: Deciding which features or capabilities deserve a place on the roadmap, and in what order.
4. How do we build it? Implementation: Writing code, testing, integrating, and deploying software. This is where AI coding tools are delivering dramatic productivity improvements.

AI has collapsed the cost of the bottom level. A weekend prototype, an afternoon demo, an agent that writes the tests. But it has barely touched the three levels above it. And when the bottom gets fast, the top becomes the critical path.
And the biggest issue here is that the three levels above implementation haven't accelerated at the same rate. Understanding customers still requires evidence. Prioritization still requires trade-offs. Deciding what deserves permanent ownership still requires a view of the company's strategy and competitive advantage.
Of course, AI can help with all those activities. It can synthesize feedback, identify patterns and evaluate options, but the decisions, and their consequences, still belong to the organization.
When implementation speeds up dramatically, the quality and speed of upstream decisions become critical to how much of that productivity becomes customer value.
That's where I believe the more consequential bottleneck shift is happening.
Faster building doesn’t automatically mean better products
The irony is that making software development dramatically easier creates a problem because we weren't particularly good at deciding what to build, even when building was expensive.
Back in 2019, before AI coding entered the mainstream, Pendo analyzed usage across 615 software products. It found that 80% of features were rarely or never used. Teams were already building the wrong things most of the time, even when every feature cost a quarter.
Now cut the cost of building by an order of magnitude and leave decision quality where it was. You don't get a better product. You get more of that 80%, faster.
As a product leader, you might think, “Well, that’s a substantial productivity improvement!” But have we created more customer value? Or have we simply become more efficient at building things customers didn't really need?
That’s why improving engineering velocity alone isn't enough: AI doesn't automatically fix poor product decisions; it simply helps us execute them faster.
Five signs your bottleneck has moved
So how do you know whether this is happening in your organization? Here are five signs:
Engineers wait on decisions, not the other way around. Specs, priorities, and sign-offs are now the queue.
Prototypes pile up. Plenty of things get built. Far fewer get committed to, launched, and supported.
Roadmap debates are about "could we" instead of "should we." Feasibility used to end the argument. Now it ends with almost none.
Output metrics rise while outcomes stay flat. More PRs, more releases, same adoption and retention.
Your best engineers are working on things a competitor could build. The scarcest talent is pointed at the least differentiating work.
Note that none of these necessarily means your engineering team is underperforming. In fact, they might be a consequence of your engineers becoming substantially more productive, and that the organization simply hasn't adjusted how it makes decisions around that new capacity.
So how do product leaders respond?
I don't think the answer is to slow engineering down. That would defeat much of the purpose of adopting AI in the first place. Instead, we need to get better at identifying, accelerating, and sometimes eliminating the decisions that constrain progress:
1. Identify where decisions are waiting. Most engineering organizations have good visibility into development cycle time, deployment frequency, and other delivery metrics. But how long does it take to decide whether a proposed feature is worth building? Or whether a prototype deserves production investment? Those queues deserve attention too.
2. Bring customer evidence closer to development. When implementation takes months, teams have time to do discovery while they build. When implementation takes days, slow feedback loops become much more visible. Product and engineering need faster ways to test whether the problem is worth solving, not just whether the solution works.
3. Be deliberate about what enters the roadmap. A working prototype is evidence that something is possible, but it isn't automatically a commitment to turn it into a product. That's an important distinction in an era where prototypes are becoming almost effortless to create.
4. Give the right people the authority to decide. If every product choice requires multiple rounds of approvals, faster implementation won't help much. Teams need clear decision-making boundaries, shared product principles, and enough customer context to make good calls without constantly escalating.
Finally, one more move I think is especially important: stop making decisions you never needed to own in the first place!
The most important decision might be what not to own
Every capability you decide to build creates more than code. It creates a stream of future decisions your team will need to make and own.
Which architecture should we use? What happens when customer requirements change? Who handles upgrades? How do we maintain security and performance? What happens when something breaks?
If you lead a SaaS product team today and are thinking about building your own AI-powered analytics experience, getting a conversational interface working with an LLM might be relatively straightforward today. But what happens when customers need consistent semantic definitions across complex datasets? Different access permissions for different tenants? Query and token optimization at scale? Governance, monitoring, and reliable answers?
In this scenario, the team hasn't just decided to build an AI feature; it's decided to own an increasingly sophisticated analytics capability, along with all the decisions needed to keep it working forever.
And every one of those decisions competes for the attention of product and engineering leaders and their teams. This is where the ownership question at the top of the Decision Stack becomes so important.
A good decision about what not to own can eliminate an entire category of recurring decisions further down the stack.
That’s the thinking behind the Three-Layer Model for Intelligent Products we introduced recently. Decide once that Layers 2 and 3 of your intelligent product, the analytics experience and the foundation beneath it, aren't yours to own, and you've removed a permanent queue of decisions from your busiest people.
That's the real value of building with ThoughtSpot Embedded. Not just less code to write, but fewer decisions to make, so your team's judgment goes where it creates advantage: Layer 1.
Next in the series: If deciding is the bottleneck, who is doing the deciding, and what are they paying attention to? The hidden cost of building software.



