Agentic AI Made Code Cheap. Decision Making Is the Moat

When agents can build almost anything overnight, the scarce asset is conviction about what to build — and a record of why.

---

For two decades, the hard, expensive part of software was writing it. That assumption is breaking. Agentic coding tools now turn multi-hour engineering tasks into minutes, and the bottleneck is moving upstream to product decision making — knowing what to build and being able to prove why. A May 2026 McKinsey report, Rewiring software delivery for the agentic era, puts numbers on the shift, and the conclusion is uncomfortable for product teams: as building gets cheap, the quality of your decisions — not your velocity — becomes the moat.

The inner loop broke the sound barrier. The outer loop didn't.

McKinsey splits delivery into two loops. The inner loop — write, build, debug — has, in their words, "broken the sound barrier." That acceleration is already mainstream: in Stack Overflow's developer survey, the large majority of developers report using or planning to use AI coding tools. Leading organisations are now running a 24-hour model where agents execute structured work overnight and humans review and re-prioritise by day, with some reporting threefold to fivefold productivity gains and a 60% reduction in team size.

Those are delivery numbers, and they describe the inner loop getting faster. The interesting part is what they expose. McKinsey's analysis finds that requirements, design, and coding and testing account for roughly 70% of technology spend — and most of that work "remains manual and interpretation heavy." Deployment, the part everyone automated with CI/CD pipelines, is only about 30%.

So as agents absorb the coding portion, the expensive, un-automated work that's left isn't shipping. It's deciding. McKinsey is blunt about where the friction lives:

"Requirements, standards, architectural specifications, and user stories live across disconnected documents and tools. Each transition introduces ambiguity. Humans repeatedly translate intent from one artifact to another."

If you lead product, that is not an engineering problem. That is your problem — and it's about to be the most expensive one in the building.

When building is cheap, product discovery is the constraint

This is a familiar argument turned up to eleven. We've written before that execution stopped being the bottleneck a while ago — coherence and clarity did. Agentic coding makes the point impossible to ignore. When an agent can produce a working feature in an afternoon, the cost of building the wrong feature collapses to almost nothing — which means you'll build more wrong things, faster, unless your product discovery is sharper than your tooling.

The numbers were already alarming before agents. Surveys of product teams find that a large majority worry they're building the wrong thing — we unpacked that 84% confidence gap and what it costs in wasted engineering. Agentic delivery doesn't fix that gap; it widens the blast radius. A faster factory pointed at the wrong target just reaches the wrong destination sooner.

And the inputs are noisier than most teams admit. Customer feedback is only a fraction of the real demand signal — roughly 20% of it, with the rest scattered across support tickets, sales calls, usage data, and churn. If agents are going to act on your decisions at machine speed, the decision had better be built on more than the loudest customer in the room.

The unlock is a memory layer for product decisions

McKinsey's central recommendation isn't "buy more agents." It's to build a "knowledge graph that functions as an AI memory layer" — a semantically linked record connecting customer feedback, decisions, tickets, and usage data, queryable on demand. They call it "the critical unlock to enable velocity and agent autonomy." Their illustration of why it matters deserves to be pinned above every roadmap:

"Every decision becomes traceable. If a stakeholder asks why a feature was deprioritized, the answer can be linked directly to its source — such as customer survey data or usage analytics."

Read that again as a product manager. Why did we deprioritise this? is the question you field in every roadmap review and every "I thought we agreed on X" thread. Today the answer lives in someone's memory, a stale doc, and a deck from six weeks ago. In an agentic operating model, an un-traceable decision isn't merely awkward — it's ungovernable. You cannot supervise a system whose reasoning you can't reconstruct.

This is exactly the gap that AI product management tooling has to close. Not "summarise this feedback" — that's a co-pilot trick. The job is to maintain a durable, evolving memory that links every recommendation back to the evidence underneath it, so the decision and its justification travel together.

Why "evolve it," not "engineer it," beats a taxonomy project

Here's the trap most teams will fall into, and McKinsey names it directly: do not start with a "grand, top-down ontology effort." Instead, "the graph should evolve organically around priority domains and live programs, compounding value over time."

That single sentence invalidates the instinct of most enterprises, which is to commission a six-month taxonomy project that ships obsolete. The reason it fails is structural: customer needs shift faster than a fixed taxonomy can be re-approved, so the map is always describing a territory that has already moved. A memory layer worth having is one that learns — topics that merge, split, and re-weight as new signals arrive, not a static tree someone has to maintain by hand.

This is also the difference between a dashboard and a decision intelligence platform. A dashboard shows you what happened. A decision intelligence platform accumulates the why — and gets more valuable the longer it runs, because the institutional memory compounds. As McKinsey puts it, the knowledge becomes "production infrastructure, rather than static documentation, and a durable source of competitive advantage."

The human job shifts from producing to supervising

McKinsey's prescription for people is equally direct: as agents take over execution, human roles "shift away from manual coordination and testing toward architecture coherence, domain modeling, and AI supervision." The same logic applies one level up, in product. The PM's job moves from writing tickets to setting the context agents operate in and judging what they produce — the rise of the context engineer.

That shift only pays off if the controls move at agent speed too. McKinsey is emphatic that governance — risk, compliance, quality — should be "baked in by design, rather than becoming a gatekeeper at the end of the process," ideally expressed as "policy as code." A faster pipeline that still funnels every decision through a manual end-of-line review just relocates the bottleneck; it doesn't remove it.

There's a quieter tax lurking here, too. If supervising an agent means re-deriving the reasoning behind every output by hand, the productivity gain evaporates — the "verification tax" that silently kills AI initiatives. The antidote is the same memory layer: when each decision arrives with its evidence and rationale attached, review becomes a judgment call, not an archaeology project. Broader McKinsey research on seizing the agentic AI advantage lands in the same place from the enterprise angle: the value isn't in the model itself, it's in the operating model and the data plumbing around it.

How Nexoro Approaches This

We didn't set out to implement a McKinsey exhibit, but the overlap is hard to miss — and it sharpened how we describe the work. Nexoro is a Product Decision Intelligence layer built on exactly the principles the report argues for.

It starts with signal ingestion across the full surface — feedback, support, sales, usage — not just the 20% that arrives as explicit feedback. Those signals are organised into a topic model that evolves as new evidence lands, rather than a hand-maintained taxonomy: the "organic, around priority domains" approach, not the doomed ontology project. Every recommendation traces back through the needs it addresses to the raw signals underneath it, so when someone asks why did we deprioritise this?, the answer is one click, not one meeting. And because the system's own agents reason over that evidence, each action they take is logged — what was decided, on what basis — so the reasoning stays reconstructable. That's McKinsey's "controls baked in by design," not bolted on at the end.

The throughline is simple. As we've argued, AI isn't your PM — judgment still matters. What changes in the agentic era is the leverage: when code is cheap to write, the quality of the decision you hand the agent, and your ability to defend it with evidence, becomes the whole game. Code is becoming a commodity. Conviction about what to build, backed by a memory of why, is the moat.

Continue reading: What Is Product Decision Intelligence?

---

Written by Dimitar Alexandrov at Nexoro — Product Decision Intelligence that connects signals to strategy. Book a demo to see how it works.