Why AI Can't Be Your Product Owner

Start With What It Does Better Than Me

I use AI for product work every day. Not just for code. The actual thinking.

It writes better user stories than most product managers I've worked with. Cleaner acceptance criteria, fewer ambiguities, edge cases I'd have missed. Ask it to tear apart your roadmap and it does a more honest job than the last three people you showed it to, because it has no political reason to be kind. Ask it to argue against its own recommendation and it will, properly, with the strongest counter-case rather than a strawman it can knock over.

The personas come back actually differentiated. The specs are better written than most specs that ship. None of that is a grudging concession, it's just true.

So when I say it can't be your product owner, I'm not saying it isn't smart enough. Any argument that depends on AI being bad at reasoning is a bet against the trend line, and that's a bet I'd lose.

The argument is structural. It's about where it sits, not what it knows.

It Can't Go and Find Out

Here's the weak version of this argument, the one I don't want to make: "AI only knows what you tell it." The reply is obvious. So I'll tell it more. Context windows keep growing. That objection has an expiry date.

The real problem is a different shape. It isn't that AI lacks context. It's that it cannot acquire context.

It can't call your customer. Can't sit in the room when the buyer goes quiet at the price. Can't notice that the person you were demoing to hovered over one button, said nothing, then didn't click it. Can't go and find the thing nobody has written down, because nobody has said it out loud yet, possibly including your customer.

Every piece of product work AI does is reasoning over what is already known.

And real product work is almost never bottlenecked on reasoning. Think about the last decision you were genuinely stuck on. Were you stuck because the analysis was too hard, or because you didn't know something and the only way to find out was to go and get it?

It's nearly always the second one.

Better models don't fix that. The next one will be sharper at the analysis and no better at making the phone call. This was never an intelligence problem, so more intelligence isn't the fix.

It Answers the Question You Asked

Second gap, and it's mutual: it applies to me as much as it does to you.

AI responds well to every question put to it. Genuinely well. If you're good at asking, you get a great deal back.

But it doesn't hand you the list of questions you didn't think to ask.

It can't. Your blind spots are, by definition, not in your prompt. If you knew to ask, it wouldn't be the thing that gets you. What you get is excellent coverage of the surface you thought to describe, silence everywhere else, and the silence looks identical to the absence of a problem.

This is what other people are actually for. A good collaborator has watched a different set of things fail than you have, and interrupts you with "wait, what happens when a customer does the thing where..." The value is in the interruption.

A system that answers is not the same as a system that asks. Both are useful. They aren't substitutes.

It Won't Hold a Line

Product ownership, on most days, is saying no to the same good-sounding idea over and over for six months.

Not saying no once. Saying no in March. Again in April, when it comes back with better justification. Again in August, when you've quietly started to think maybe it's fine actually.

That's the job. Most of it. The conviction isn't in the original decision. It's in the two hundred small refusals that follow.

AI has none of that. Ask it today and it agrees the feature is out of scope, with good reasons. Ask tomorrow, phrased slightly differently, with a bit of your own enthusiasm behind it, and it finds the case for it. Not because it's weak. Because there's no position there to violate.

Memory doesn't fix this. It recalls the decision perfectly and helps you unmake it in the same reply, because recall isn't conviction. Conviction is resistance, and resistance is what the thing is built not to have.

It's a mirror with a very large vocabulary. Push and it moves. Intelligently, in well-structured prose, with reasons you'll find persuasive. But it moves.

It Has No Stake, So It Will Never Tell You to Stop

This is the one that matters, and the one I'd want to be wrong about.

Everyone else in a product has something to lose. The engineer has to maintain it. The designer's name is on it. You have the whole thing riding on it.

AI loses nothing if you build the wrong product. It's exactly as helpful on the doomed idea as on the good one, right up to launch and past it. Spend eight months building something nobody wants and it will spend eight months being sincerely useful, and nothing in that process will ever register a problem.

And the failure mode this produces isn't bad code. It's building forever without ever deciding.

The mechanism is worth being precise about.

Building used to be expensive, and that expense quietly forced a choice. You could build three things this quarter, so you had to work out which three, and that argument was where the product got its shape.

That constraint is gone, and what replaced it is not judgment. It's nothing. So you build forty things instead of three, and forty is not the better product. It does forty things adequately and nothing decisively. A user can't tell you what it's for in one sentence, and neither can you.

Nothing in the loop ever says no. That's the whole of it. The only other participant in the room is infinitely accommodating. No fatigue signaling that this is too much. No budget running out. No pause across the table when you say "actually, while we're here, let's also add..." Every constraint that used to say stop has been engineered out, and stopping was doing far more work than anyone gave it credit for.

You didn't remove friction. You removed the only thing making you choose.

The Job That's Left Is Being the Constraint

So what survives? Not "writing specs," AI does that better. Not prioritization frameworks, it runs those more consistently than I do.

What survives is narrower and harder than the job description most product people carry:

• Saying no, and meaning it again next month. Holding the line when the idea comes back wearing better clothes.
• Having a stake. Stakes make stopping possible, and stopping is the one decision nothing else in the loop can make.
• Going and getting what isn't known. Making the call, running the test, sitting in the uncomfortable room. Reducing uncertainty by acquisition, not analysis.
• Asking the unrequested question. Bringing what was never in the prompt.

That's a function, not a job title. It might be you, on a specific day of the week, deliberately being difficult with yourself. It might be a co-founder who won't let a thing go, or one user who tells you the truth. What matters is that it exists somewhere in the loop, because it's now the sole supplier of the constraint the cost of building used to provide for free.

You mostly notice it by its absence.

How to Put a Constraint Back in a Solo Loop

Four things I do imperfectly.

Write down what you are not building. Not a backlog. A not-list, kept where you'll see it more often than you'd like. The value isn't the list. It's having to cross something off it before you're allowed to build it.

Pick one decision you'll refuse to revisit for 90 days. One. Choose it carefully, because you'll want to reopen it around week three and you don't get to. That's the exercise: manufacturing the continuity the loop can't supply.

Argue the opposite before you add anything. On paper, the strongest version of the case against. You can have AI build that case, it's excellent at it. The trick is doing it before you start building, while being persuaded is still cheap.

Notice when you're adding something because it was easy. Easy and needed used to feel like the same thing, back when nothing was easy, so most of us never learned to tell them apart. The tell is how fast you moved from "we could" to "I've started." If there was no gap, nobody decided anything.

---

The bottom line: AI will build anything you ask it to, at a quality that keeps surprising me and a speed I find unreasonable. It will never tell you what not to build. Not because it isn't clever enough to work it out, but because it has nothing riding on the answer and no reason to hold the same position tomorrow. That absence is the entire job. Everything else in product work is getting cheaper. That one thing hasn't moved.