The Backlog Was Never the Job

---

The same week, my feed buried the Product Owner and saved him.

Four posts, four authors who don't know each other, four angles. A lead product manager wrote that the PO role was always an organizational aberration and has become indefensible in the AI era: hiring someone to feed a backlog, write tickets and relay information between business and developers is optimizing an organization that is already obsolete. A transformation consultant answered, without knowing she was answering: her team generated two days' worth of user stories in two hours, well-written, well-sliced — and disconnected from the field constraints only real interviews would have surfaced. Her conclusion: the tool saved hours of drafting and not one minute of understanding, so the PM's value moves to arbitration and to field knowledge that cannot be delegated. A staff platform engineer admitted he no longer has the capacity to review all the code his agents produce, and that line-by-line review is probably no longer the right fight: invest in specifications, give the agents the means to test their own work, demand verifiable reports. And an independent developer observed that a single person can now carry a product end to end — code becoming one means among others, no longer the main activity.

Each of them is right about their segment. They just aren't describing four different things.

Four angles, one event: production stopped being the scarce thing.

I wrote the engineering side of this a few months ago: coding was never the job. This is the product side, seen from where I sit — an engineering lead on regulated healthcare software, on the other side of the wall from the product people. And from that side, the debate about whether the PO is dead misses the corpse.

What the product week was actually made of

Take an honest inventory of what the transmission-belt configuration filled a week with. Feeding the backlog. Formatting tickets so developers would accept them. Relaying a user's answer to a developer's question, then relaying the follow-up question back. Chasing status updates to feed a steering committee. Reformatting the same information for three audiences. None of this was ever the job. It was the packaging around the job, and it expanded to fill the week because someone had to do it and the tools were bad.

That packaging is what agents absorb. On my team this is no longer an experiment; it is written down as method. I have already described the agents that triage incoming tickets and the persona panels that debate a design before a human reads the synthesis. On Solstice*, the loop has closed further. The weekly product workshop — PO, PM, tech lead, designer — is recorded. Within the hour, an agent has turned the transcript into the minutes, the business rules, and ready-to-build issues. Nobody writes tickets after the meeting anymore. The meeting became the deliverable: the context, the constraints, the arbitration — what happens in the room is the only part automation cannot extract on the way out. And when we wrote down the open fronts of our own method, the active frontier was not the code. It was the specs. That finding ended up earning its own post: the doctrine that compounds while models depreciate.

The daily version has the same shape. Twenty minutes of context assembly by someone who knows the domain, thirty seconds of generation, then the conversation that actually matters — this draft contradicts the retention policy, kill it; these two stories assume the same screen, merge them.

The brief became the work. The drafting was only ever the packaging.

One thing the gravediggers get wrong, though. The ticket-clerk PO was not born a clerk. Marty Cagan has said for a decade that "product owner" names a set of responsibilities in a delivery process, not a profession — and that feature-factory organizations manufactured backlog administrators by design: output roadmaps, proxy stakeholders, no mandate to talk to users. Keep his taxonomy, keep your skepticism — he has been selling the empowered-team alternative for twenty years. But the diagnosis stands. It was the surrounding organization that dressed the role up as a relay station. What AI removes is not the person. It removes the excuse for that configuration.

What survives — and who signs it

So what is the judgment share made of, concretely? Three things, seen from the engineering side of the wall.

Arbitration. When an agent generates ten plausible hypotheses in thirty seconds, the scarce act is choosing: what we keep, what we test, what we throw away. A choice that holds when the client escalates, which means a choice someone is accountable for by name.

Refusal. The most valuable sentence a product person says to my team is no. No, this drafted requirement contradicts how the certified module handles retention. No, we will not ship this to satisfy one hospital's workaround. Refusal requires knowing why, and being able to say why in language an auditor accepts.

The field. Agents interpolate from tickets, and tickets lie by omission. Nobody's backlog contains the fact that the night-shift nurse uses the software with gloves on, standing, interrupted every ninety seconds. Someone has to have watched. That knowledge does not come out of a language model, because it was never written down anywhere a model could read it.

My industry adds a fourth thing, and it is the one the LinkedIn debate never touches. In regulated healthcare software, a requirement is not a to-do item. It is a compliance artifact. The chain from user need to requirement to architecture to verification test is not bureaucracy; it is the thing the auditor reads, and every link carries a human signature that means something. An agent can draft every link of that chain. It cannot own a single one. "The agent generated it" is not provenance an audit accepts — the questions remain: who reviewed it, when, under what procedure.

And here the acceleration cuts both ways. A product owner who wrote twelve requirements had read them. A product owner who approves sixty agent-drafted requirements per sprint is a click-through risk. The failure mode is not new. I have already been burned by a checkbox that everyone trusted and nobody read; the same checkbox is now waiting inside the traceability chain. AI makes the chain cheaper to produce and more dangerous to rubber-stamp. The trap even has a recognizable shape: a generated story that is internally perfect — testable, well-sliced, INVEST-compliant — and wrong, because it assumes a field can be edited when it is in fact locked after signature for legal reasons. Every test passes. Only the person who knows the domain flinches. That person is the exact mirror of the engineer I described in the coder post: the one who notices something is wrong when everything is green.

The boundary dissolves — and the trap accelerates

Now put the two sides of the wall together. My engineers, driving agents all day, make product micro-decisions hourly: this edge case matters, that one doesn't, this error message will confuse a nurse. The product people, briefing agents that draft their specifications, are doing design. DORA's 2025 research describes the same blur from survey data — product managers and analysts now use AI to do technical work that used to be beyond their reach, engineers absorb product work — treat the percentages with the usual survey caution, but the direction is symmetrical. On Solstice, our own method says it in its impact table: the developer becomes an orchestrator of agents; the designer guards a design system instead of producing mockups; the PO feeds context through the workshops; the PM steers by measured delivery numbers instead of estimates. Four roles augmented, none eliminated. The two sides of the wall are not trading tasks. They are converging on the same scarce thing.

AI accelerated production. It did not accelerate understanding the problem. It made understanding the only expensive thing left.

Which is exactly why the acceleration is dangerous. Ten hypotheses in thirty seconds is not ten times more understanding; it is ten times more output against the same discovery deficit. Melissa Perri named this trap years before the agents arrived: a team measured on output ships features nobody needs, faithfully and forever. A feature factory with agents is a faster feature factory. I made the same point about my own field in the DORA post: AI amplifies the system you have. If your product organization was a transmission belt, automation makes the belt spin faster. It does not tell you the conveyor is pointed at the wrong wall.

The trap has a second level, and it sits in my own office — my team is the counterexample to any tidy story. We grew this year — interns and apprentices included. Distributed product judgment is a senior-team luxury. A senior engineer with years in the domain can absorb arbitration; an apprentice given the same fused role produces confident, well-formatted, wrong decisions — faster than before, because the agent formats the wrongness beautifully. And the relay work, whatever its waste, was, by accident, a training ground: writing tickets badly was how juniors learned the domain. Remove the relay and you remove the on-ramp with it. The replacement has to be built on purpose — juniors in the user calls, juniors reviewing requirements next to a senior who explains their no. It is the same junior-pipeline problem I flagged for engineers, transposed to product. Nobody inherits judgment. Someone teaches it.

What still belongs to humans

The list, stated plainly, because this is the section the obituary posts skip.

Named accountability. Judgment can spread across a team; responsibility cannot. Someone still signs the priority call, the requirement, the refusal — someone is still the name the auditor writes down and the person the client calls at 8am. "Everyone owns the product" is the fastest way for nobody to own it.

Discovery. No agent talks to your users. The interviews, the observation, the workflow watched in situ — untouched by everything above.

Political arbitration. When a client's medical director wants a feature the risk analysis argues against, that negotiation runs on a trust relationship built over years. No generated spec settles it.

Teaching. The apprenticeship path for product judgment, now that the tasks juniors learned on are automated.

And what this post does not say: that you need fewer product people. The freed hours have a destination — discovery, the field, the regulatory work that was always underwater. Cutting the people would mean cutting the judgment this whole article just argued is the only expensive thing left. The teams that win will be the ones that reinvest the hours, not the ones that harvest them.

Monday morning

1. Audit one week. Take a real week of product time and sort every hour: transmission or judgment. Not to cut anyone — to know what you should automate and what you should protect.
2. Move one relay loop to an agent. Story drafting from a brief is the obvious first one. With a named human reviewer at the end of the loop, and a rule that approving without reading is the failure mode you are watching for.
3. Make the brief the deliverable. Context, constraints, what is forbidden and why. Judge the week by the quality of the briefs, not the volume of tickets.
4. Put an engineer in one user call per sprint. And a junior next to them. The wall falls faster when people cross it in both directions.
5. Rewrite one epic as a problem statement. Not a list of tickets — a description of who hurts, when, and how you will know it stopped.
6. Name who signs. For each product decision chain, one accountable name. If you cannot find the name, you have found the problem.

Read the rest of the series: The SDLC Is Dead — why the process was always waste. Coding Was Never the Job — the engineering side of this exact argument. AI Became a Team Reflex — what an AI-native team looks like on a Tuesday. DORA Just Confirmed What My Team Already Lived — the amplifier, measured. 100% Agent-Written — six months of agents, graded. Doctrine Compounds. Models Don't. — where the rules that outlive the models live. The Tests Passed. Nothing Happened. — the defect that has no symptom, and what catches it instead of reading. The Skill Was Real. The Seat Wasn't. — what this post's diffusion looks like once the team is small enough to collapse to one name.

---

Sources

• SVPG — Product Manager vs. Product Owner: Cagan's decade-old distinction between the Scrum role and the profession. He sells the empowered-team model — keep the taxonomy, keep your skepticism.
• SVPG — AI Product Management: 2 Years In: the January 2026 piece splitting delivery-team PO, feature-team PM and empowered PM, and predicting the reckoning for the first two.
• Melissa Perri — Escaping the Build Trap: the output-vs-outcome frame this post leans on. Written before agents; more relevant since.
• DORA — 2025 State of AI-assisted Software Development: the bidirectional role blur. Self-reported survey data — directions, not decimals.
• Mind the Product — What the data tells us about tech and PM layoffs: the senior-exit numbers. Nobody can cleanly separate AI from the post-2021 correction, and honest sources say so.
• Solstice* — the team's written AI-native method: the weekly workshop cycle, the role impact table, the open-fronts list naming specs as the active frontier. Internal document, no link: the codename is fictitious and the real project, its products and its vendor are anonymized.
• Four LinkedIn posts, paraphrased anonymously with their arguments intact. The authors don't know each other, or me. That's rather the point.