Almost everyone with something serious to say on the subject agrees that code is no longer the job. Andrew Ng puts it this way: “Because we can now build fast, a greater fraction of time must be spent deciding what to build” (The Batch, April 2026). Marty Cagan, from the other side of the argument, quotes Hilary Gridley: “It’s never been faster to build, which means it’s never been easier to run 10 times faster in the wrong direction” (SVPG, July 2026). Where they disagree is on who should do that new work, and that is the argument most technology functions are having without knowing they are having it.
My position is this. A technology function has two jobs left that are not writing code: building the machine that produces software with agents, and getting close enough to the business to propose things it has not asked for. The second lands squarely on product’s territory. That collision does not resolve itself, and letting friction resolve it produces the worst possible outcome: two functions writing specifications for the same agents, or neither.
This is no longer a hypothesis
It is worth fixing where the frontier sits today, because the conversation in many leadership teams is still anchored on autocomplete assistants. At OpenAI, a team that grew from three to seven engineers built a product of roughly a million lines in five months without writing them by hand, in about a tenth of the time estimated for doing it conventionally. Their summary of the model fits in four words: “Humans steer. Agents execute.” (OpenAI, February 2026). Stripe’s internal agents are “responsible for more than a thousand pull requests merged each week”, which humans review but do not write (Stripe, February 2026). Airbnb migrated nearly 3,500 test files in six weeks against an estimate of a year and a half of engineering time (Airbnb Engineering, March 2025).
These are software companies with platform teams well above the average. That does not invalidate the evidence: it shows where everyone else is heading, two or three years behind.
The first job: the machine
The same OpenAI team says where the hard part now sits: in “designing environments, feedback loops, and control systems” that let agents build reliable software at scale. Birgitta Böckeler of Thoughtworks reduces it to an equation: Agent = Model + Harness (martinfowler.com, April 2026). You buy the model. You build the harness: the guides that steer the agent before it acts, such as standards, conventions and specifications, and the sensors that observe what it did and let it self-correct, such as tests, static analysis and observability.
The way of working this enables does not resemble programming. In a migration you deliberately make the change that breaks the build, let agents repair in the background, read on a dashboard which classes of failure remain, categorise them and launch another round. Mitchell Hashimoto gives the operating rule: “anytime you find an agent makes a mistake, you take the time to engineer a solution such that the agent never makes that mistake again” (February 2026). That is maintaining a production line, not using a tool.
The 2025 DORA report, with around 5,000 respondents, supplies the finding that should set investment priorities. AI now improves throughput and still degrades stability: “Without robust control systems, like strong automated testing, mature version control practices, and fast feedback loops, an increase in change volume leads to instability” (DORA, September 2025). Its headline line is the most quoted and least applied: AI doesn’t fix a team; it amplifies what’s already there.
My view here is blunt. Most organisations are treating this as tool adoption and measuring it with adoption metrics: active licences, acceptance rate, hours saved. It is infrastructure, and it needs what any infrastructure needs: an owner, a budget and a roadmap of its own. The piece almost nobody has is continuous verification that what runs in production still does what the specification says. Without it, all the generated code piles up in front of reviewers who wrote none of what they are reading, and the constraint moves from writing to reviewing without anyone having decided it should.
Roles become liquid
Boris Cherny, who leads Claude Code at Anthropic, describes his team like this: “everyone codes. Our product manager codes, our engineering manager codes, our designer codes.” He puts the overlap between roles at around 50% and expects the software engineer title to give way to “builder” (Lenny’s Podcast, February 2026). Ng describes teams pushing engineer-to-PM ratios down “from, say, 8:1 to as low as 1:1” and backs the generalist: “When an engineer understands users and can make decisions on what to build and build it directly, they can execute incredibly quickly.”
The chain in which one person captures a need, another translates it into requirements, another designs it and another implements it existed because implementation was expensive. When implementation is cheap, every handover adds nothing but latency and lost information. The split that follows is blunter than a new role with an attractive title. Some profiles move toward the problem, the domain and the specification. Others go deep into what agents do not solve: systems design, non-functional requirements, and decisions whose cost shows up three years later. The profile left without a place is the one in the middle, the translator.
The collision with product
This is the conflict almost no analysis of the subject names clearly. Product has been bundling three things that are now coming apart: the decision about what gets built, the conversation with the customer and the business, and the specification. All three sat with product because engineering was busy building. Engineering now has time, and the specification has stopped being a document and become the input an agent executes.
The two camps are well defined. The builders’ camp, with Cherny, the PostHog team, Gergely Orosz and partly Ng, holds that whoever is closest to shipping should own all three. The product camp, with Cagan, Shreyas Doshi and Teresa Torres, holds that judgement about value and viability is a distinct skill, and that cheap building makes every bad decision more expensive. Cagan put it in writing at the end of September: “Engineers, designers and product managers still exist, and I argue the skilled ones are more important than ever” (SVPG, September 2026). The market has not bought role collapse either: in March there were more open product manager roles than at any point since 2022 (Lenny’s Newsletter, March 2026). And Böckeler points to the gap nobody covers: spec-driven development tools assume the developer will do the requirements analysis, and “None of this is made explicit though” (martinfowler.com, October 2025).
My position has three parts, and none of them splits the difference.
The specification belongs to whoever builds. A specification an agent will execute has to anticipate edge cases, non-functional requirements and consequences elsewhere in the system, and anyone who cannot judge those produces wrong code at high speed. The product manager who works as planner, status reporter or firewall between business and technology has no function in the new model. That profile disappears, and it is better to tell the people in it early.
The decision about what gets built does not pass automatically to engineering, and this is what the builders’ camp leaves out. Almost all its examples come from companies making tools for developers, where the engineer is the customer and product judgement comes bundled. In a hotel distributor, an insurer or a retail chain, the engineer is not the customer. There, judgement about which problem is worth solving and what it is worth stays scarce, and whoever genuinely has it comes out stronger. Fewer product managers, better ones, owning the problem rather than the backlog.
The boundary between the two is the most important design decision in the operating model, and it has to be written down. Product answers for the why and for whether it worked commercially. Technology answers for the specification and for what was built doing what it says. If nobody answers when an agent-built feature works technically and fails in the market, the model is badly designed, however good the pipeline.
The second job: getting close to the business
The classic division of labour was comfortable: the business said what it wanted and technology said what it would cost. The business is what breaks it. When the range of the possible widens this fast, the business asks for what it knows exists, which is what existed two years ago. Gartner asked 456 CEOs and senior executives: 66% said their business models are not fit for AI, and only 44% considered their CIO AI-savvy (Gartner, May 2025). The finding cuts both ways: the business does not know what to ask for, and does not trust technology to tell it.
Technology holds an asset it has been spending badly. The business describes the happy path; technology knows the edge cases and has had to formalise processes the business kept vague, because a system does not tolerate ambiguity. That knowledge used to be consumed arguing requirements mid-project. In the new configuration it is what makes proposing possible.
The link to the previous conflict is direct. A technology function that only talks to the business through product cannot get close to it. Getting close means engineers with product judgement sitting where business decisions get made, next to whichever product managers remain rather than behind them. And it means developing something technology has traditionally lacked: its own view of the business, defensible in front of the people who run it. This is not about being a more attentive supplier. It is that the business no longer knows what to ask for.
What to measure and what to decide
Adoption metrics rise easily and move nothing. Two numbers do say something. The first is the time from someone having an idea to it running in production, measured end to end with the waiting included: it tells you whether the machine exists. The second is the share of what gets built that technology proposed rather than received: it tells you whether technology got close to the business.
And there are three decisions a leadership team has to take in writing this year: who owns the specification, who owns the problem, and who answers when something built by agents works technically and fails in the market. Organisations that do not take them will not end up without agents. They will end up with agents producing, at full speed, whatever the last person in the room asked for.