The handoff didn't die. It moved into the repo.

All the table needed was a tooltip

Someone wanted more information on a data table. An engineer fed the request into Claude and got back “a stack of 3 PRs totaling 1,200 lines with new endpoints and UI components. All the table needed was a tooltip.”

The product tech lead who posted that in August 2026, at 1,820 points, was not describing an incompetent engineer. Somewhere in that loop, a thirty-second question went unasked, and they put the loss precisely: “Before, the engineer would probably ask someone with more understanding of the domain and learn why the tooltip is all they needed. This creates two domain experts. Now, we are ensuring we have none.”

For twenty years the industry argued whether the layer between engineering and product was too thick. It is now dissolving from both ends: engineers absorbing product decisions because implementation stopped being expensive, and product managers shipping software because building stopped requiring them to ask. The question is what the handoff turned into after it stopped being a person.

The middle compressed. The ends didn't.

Arvind Narayanan and Sayash Kapoor described software work in June 2026 as a decide-execute-deliver sandwich: “AI has compressed the middle of the sandwich, but has left the two ends largely unchanged.”

Mert Demirer, Leon Musolff and Liyuan Yang put numbers under it in May 2026. Writing Code vs. Shipping Code is a matched event study across more than 100,000 GitHub developers joined to their AI usage telemetry. Autocomplete, interactive agents and autonomous agents raised coding activity by 40%, 140% and 180%. But those gains “attenuate sharply across the production hierarchy: the 180% cumulative effect falls to 50% for the number of projects, and to 30% for actual releases.” Across four app marketplaces the authors found “a moderate increase in the number of new apps but no increase in total usage.”

Cumulative effect on coding activity

180%

Autonomous coding agents, measured against matched controls across 100,000+ GitHub developers.

Same effect, counted as projects

50%

The first place the gain leaks out.

Same effect, counted as releases

30%

Across four app marketplaces: more new apps, no increase in total usage.

Nearly triple the commits. A third more releases. Nobody using more software. That gradient is the tooltip story at population scale.

In March 2026 a team lead asked r/ExperiencedDevs whether LLMs were speedrunning everyone into product management: “roughly 4-5x speed improvements on individual coding tasks with LLMs. But when we looked at total project delivery time, it was maybe 1.5-2x faster since we enabled claude code and got cursor licences.” Self-estimated rather than instrumented, but the post drew 235 points and 154 comments, mostly from people recognising their own quarter.

Faros AI put telemetry behind the review half in April 2026: two years of data across 22,000 developers and 4,000-plus teams, comparing each organisation's lowest-AI-adoption period against its highest. Epics completed per developer rose 66%, median time in review 441.5%, the incidents-to-PR ratio 242.7%, and pull requests merged with no review at all, human or agentic, 31.3%.

The work did not disappear. It sloshed to the ends, where the humans still live.

The PM layer isn't vanishing. It's losing its middle.

SignalFire's State of Talent Report, published 22 June 2026 from profile data on 650 million individuals, names it: “Product Managers at Tech Majors now support 22% more engineers than they did in 2019.” Product management hiring at those companies is down 39% from the 2019 baseline. Engineering hiring is down 11%. At early-stage startups PM hiring is up 2%.

Mind the Product, citing Live Data Technologies on 25 June 2026, measured the cuts against the 2022 peak: VP-level PMs are down 38%, directors 35%, managers 31%, and senior individual contributors only 21%. The higher you sat above the work, the harder you got cut. These are Live Data's figures rather than Mind the Product's own, and I could not reach Live Data's publication of them.

And yet Lenny Rachitsky reported in March 2026 that there are “over 7,300 open PM roles at tech companies globally, and trending up”, “75% above the low we saw in early 2023, and already up nearly 20% since the start of this year.”

All three are true, once you keep the baselines straight. What's dying is the part of the job that carried intent from one room to another.

Alongside a 14% headcount reduction in May 2026, Coinbase's Brian Armstrong described experimenting with “one person teams”, capped the company at five layers, and replaced “pure managers” with player-coaches. His stated reason was that layers “create coordination tax.”

The traffic runs both ways

Anthropic's June 2026 telemetry across roughly 400,000 Claude Code sessions from about 235,000 people: “people in software-related occupations reach verified success in about 30% of their sessions overall, while users from other professions reach verified success about 26% of the time.” For code-producing sessions the numbers are 34% and 29%.

Figma's 2026 AI Report found the same crossover in design, from 8,403 survey responses in June 2026: “In the last year, the number of designers participating in development doubled to 41%, and the number of developers doing design work rose from 44% to 60%.” Self-reported, but directionally consistent with the telemetry.

In April 2026 a product manager drew 701 points on r/ProductManagement with: “More than half of my working day now happens in a terminal and VS Code. I'm a Product Manager. That's not supposed to be what my days look like.” No CS background. MCP servers into Notion, Slack and Metabase.

A software engineer in July 2026: “Vibe coding has switched me to product (and project) manager. Why would I care about what the code looks like? Does it work!? Does it do what I want? Does the app have the right UI and UX? These are my concerns now. I rarely look at the output code.”

A commenter described their wife's PM team at a FAANG in June 2026: “They're not learning to code, they don't even look at the code a single second.” What they replaced was not engineering. It was Word and Excel.

PoC is the new PRD

On 5 August 2026, a commenter on r/ProductManagement answered a dev asking about vibe-coding PMs: “I have a PM + Designer duo who ditched PRDs, figma and everything and just collaborate on vibe coded prototypes, it works extremely well and engineers like it much better as it's less abstract and let them focus on actual scalability, performance and so on”. 102 upvotes, from engineers. A May 2026 thread on “Product Builder” as a job title put it in four words: “Poc is the new prd”.

Harrison Chase of LangChain reached the same conclusion in March 2026: “I think the traditional PRD process (PRD → mock → code) is dead.” His replacement is posed as a question rather than a claim: “What if PRDs of the future are just structured, versioned prompts?”

An engineer described an AI-native internal project in April 2026 where nobody had written a line of code by hand: “The first rule was our product manager, who is technical but isn't typically in the weeds, needs to be able to one-shot prompts with cursor auto. And so many rules stem from there, from e2e tests to ensure he doesn't break stuff, to custom linters to ensure that code lives in the right place, to architectural spec sheets so the LLM doesn't try to do raw DB queries from the client.”

• End-to-end testsSo the person driving cannot break what they do not understand.
• Custom lintersSo generated code lands where it belongs instead of wherever the model felt like.
• Architectural spec sheetsSo the boundary is stated once, in the repo, rather than re-explained per ticket.

Another engineer described the same migration in May 2026: “a lot of the stuff that used to be floating around people's heads or in various other places like the ticketing system or wiki, is (supposed to be) kept inside the (or a separate ‘docs’) repo.”

The handoff layer got committed.

What doesn't compress

The strongest case against all this came from a PM at Google in April 2026, at 352 upvotes: “PRDs are often not for the Dev team. Devs usually know what to build better than the PM, and they flesh out amazing Design Docs that go in depth on how the product should work. PRDs at Google are usually for stakeholders, eng managers, legal, analysts, copywriters, policy, T&S, etc. It's a tool to drive alignment, not an IKEA manual on how to build a product.”

A prototype can replace a build-instruction document. It cannot replace a legal review. The top comment on an April 2026 thread on the PM job in 24 months, at 385 upvotes, was blunter: “Cross functional alignment can't be solved by Claude and engineers don't want to deal with it. Hence PMs”.

Karim Jedda, a director of engineering, named the mechanism in July 2026: “The slowest part of verification was never the checking but accountability... Sign-off time does not compress, because it is not information processing. It is risk acceptance.”

The honest rebuttal, from a PM in the same thread, at 43 upvotes: “If all that's left of PM is to get cross functional alignment, the PM role is not valuable at all. They can do that themselves. It's also no longer a fun role.”

Both are right. The residue is real, and it is not obviously a career.

More documents, fewer decisions

A senior PM at a fintech, six months after org-wide AI adoption, in July 2026: “we now produce 3x the PRDs, specs, and analysis docs. Leadership loves the velocity. The quality of the decision behind them is worse.” And then: “The hard part of the job was never writing the PRD.”

A developer described their pipeline in August 2026: “product manager can produce longer requirement doc easily (we can use LLM to read it anyway:) Meeting sometimes is more than before, because more document output leads to more reading and discussion.”

The Glean Work AI Institute, reported in June 2026 from a survey of 6,000 full-time workers in the US, UK and Australia fielded between December 2025 and January 2026, found 87% using AI and 75% saying it made them more productive. Only 13% said their organisation performs significantly better because of it. That last number is perception, not audited output.

An observational study of 20,574 real coding-agent sessions across 1,639 repositories, published 28 May 2026, found that “90.50% of episodes impose effort and trust costs rather than irreversible system damage, yet 91.49% of visible resolutions still require explicit user correction.” The handoff moved from human-to-human to human-to-agent, and it still breaks on underspecified intent. Only now it breaks silently, at volume, and at three in the morning.

The weird new kind of PM

A practitioner in March 2026, replying to that r/ExperiencedDevs thread, named the skill that became the whole job: “the bottleneck is not exactly coding or planning. it is task decomposition. being able to break work into units small enough, well-specified enough, and self-contained enough that an agent can execute them without needing to ask you anything.”

They then reported: “the pms on our team actually struggled with this more than the senior devs at first. they were writing tasks in a way that made sense to a human who already knew the codebase. an agent needs everything explicit - the constraint, the scope boundary, what done looks like in testable terms.”

Both roles are converging on a third job neither was hired for: writing the boundary precisely enough that a machine can execute inside it and a human can sign off on the result.

Karim Jedda drew the line: “Teams with strong specs get the full benefit of cheap checking. Teams with weak specs get generated code reviewed by the same machine that generated it.”

A more brutal version is doing the rounds, and it is half-true. A commenter on 11 February 2026, on a thread that reached 1,085 points, argued that PMs are being squeezed from above and below: “If it's simple and easy: the user took it over, if it's complex: it's going to the smartest person in the room. That has never been the PM.”

Maybe. But the tooltip story says the opposite, and more urgently: the smartest person in the room shipped 1,200 lines because nobody in the loop knew the domain well enough to say tooltip. Neither title protects you from that. Only the spec does, and the spec is now a file in your repository that a machine reads, a test enforces, and a person signs. That is the first version of the handoff anyone can check.