“AI PM” can mean two things.
A PM who ships AI products. Or a PM who runs their own work through agents.
For me it’s both. But they don’t need to overlap.
Either way, a product management career in the age of AI needs to be organized around decision rights.
What can you decide?
What evidence do you need?
Where does your authority stop?
Who’s accountable for the answers when it goes wrong?
There’s a lot of advice out there about being an AI PM. Learn to prompt well. Learn to evaluate. Prototype. I’d want any PM I managed to be able to do those things. But none of them defines what the PM actually owns.
The job market has “AI PM” at nearly half of all listings. But that’s nothing more than a title match count. It doesn’t tell you which kind of AI PM. Or it’s just a buzzword that doesn’t change the job description at all.
Not just what to build, but who gets to choose
It’s a fairly broad consensus that the “hard part” of product has moved from building to choosing what to build. I agree - though wasn’t that always the case? It’s not the full question, though.
Who has the authority to make that choice?
An agent can read a batch of customer feedback. It can compare that against organizational priorities. Then it can recommend moving a feature up the list. It writes the spec. It even builds a working prototype.
Changing priority is a management decision. Who answers for that change if it breaks some other commitment? The agent can’t. But if a PM is just a rubber stamp for an agent decision, neither can they.
The better the recommendation, the harder this gets. We see multiple plausible options, all arriving at once, with the capability for near instant execution.
We need to determine whose commitments, constraints, and budget each kind of decision touches.
Then we can start to define an “AI ready” PM ladder.
Early career: having calls to own
Early career PM work is often process and execution focused. Write specs. Triage the backlog. Update status.
It can be frustrating. It’s where product management most often comes to resemble project management. But it’s also how newer PMs learn how and why decisions and priorities change.
Agents can do a lot of that work now.
An obvious but dangerous approach would be having junior PMs review what agents produce. That’s going to fail. If it’s a finished recommendation, the decision is already made. We’re straight back to the rubber stamp problem - and the PM has no real autonomy.
So put them into the problem before there’s an answer.
Early career PMs should define the tests before an agent runs. What’s the question we want to answer? What are the constraints? What evidence will change our mind?
The agent then works inside the boundaries the PM set. When there are options that diverge, it needs to stop and show its evidence. The junior PM can pick a branch and the agent can run it.
We’re taking advantage of agentic speed. But the PM is the one making the choices. The calls they make are theirs; and there’s a record that they can genuinely stand behind.
For this to work, someone more experienced sets the boundaries - and pairs with the junior on how to make the call, not just how to reach a particular outcome.
Mid career: own those frames and those forks
I’ve written about how I’ve tried to build trust gates into my agentic product flywheel. And - even when it’s getting most things right - I still don’t trust it without a human in the loop.
But where does that loop live? If PMs are approving finished issues and project stubs, they’re a rubber stamp again.
Where a junior PM owns a single call inside a boundary, a mid-career PM owns the boundaries themselves. They sit at the start of a stream of work, and at every point where it can branch, built around three things:
The frame: Agents can draft a spec. But they also need to know what the team is already committed to. And why this work is being prioritized. A PM writes that down before an agent runs. They also need to write down the risks and unknowns. That PM can answer for the quality of the agent spec, and also know when circumstances mean it’s out of date.
Forks in the road: Left to their own devices, agents don’t stop and ask. They forge ahead. PMs need to define in advance where those pauses need to be. Requests outside the roadmap. Gaps that an agent will make up a solution for. Commitments outside this team. The agent can run everywhere else; but if it stops too often, or too rarely, the PM can fix it.
The decision record: Every time there’s a fork, a decision is made. Write down the why, as well as the what. Other people will need it. So will other agents.
Executive: documenting the mandate
Senior product leaders define these decision rights. They need to do so in a way that works across different teams and different systems.
What does the agent get to decide?
When does it have to go back to a PM?
What circumstances call in engineering, security, another product team, or an exec?
Who is accountable for what result?
Don’t skimp on that documentation.
“Humans approve important decisions” is something I’ve seen given as an agent instruction.
It’s useless. An agent doesn’t know which decisions are important.
We need to give it clearer direction. Perhaps something like: “An agent can file, dedupe, and link incoming requests to existing roadmap items. It can’t create a new roadmap item, or close a request as won’t-do.”
I can only hold someone I manage accountable for work if they have the scope to manage, inspect, and own that work. They need to be able to push back on rules. They need an escalation path.
If I assign responsibility without empowerment then I’m setting people up to fail.
Build from one decision first
I don’t want to see the first rung on the PM ladder become “review what the agent did.” That’s not guidance. And reviewers who haven’t owned the call don’t have the experience to distinguish between a good recommendation and one that just sounds really persuasive.
Left unchecked, that’s going to move up the PM ladder. Then the top rung will be assigning accountability, without giving anyone the authority to own it. That risks becoming a blame culture.
Take a look at the decisions your team makes. Pick one, whether it got made by a person or an agent. Write down what got decided. Take a note of who reviewed what. And who gets to say the work can be committed.
Help an early-career PM understand how to see that decision through.
Then those PMs are prepared to work with agents. Not just say yes to whatever they recommend. Partner with, direct, and manage them.
Further reading:
Gupta, A. How to Become an AI PM (without AI PM experience). Product Growth, Aug 2026.
Moretti, M. Agent-native Product Management. Every (paid article).
Daly, J. Intentionally Human: Product Managers in the AI Era. Jeremy Daly, Oct 2026.
Sammane, Dr S. Trustworthy AI Begins With Accountable Humans. AI Time Journal, Oct 2026.
Article photo by Glen Carrie on Unsplash.
