Martin Mexia

What Do We Pay Product Managers For Now?

For most of my career, product managers were the only people in the building who could actually launch a product. That just stopped being true.

For most of my career, the product manager was a translation layer.

Business speaks revenue. Engineering speaks code. Product sat in the middle, converting one language into the other. Roadmaps, specs, tickets, prioritization meetings, status updates: all of it translation, moving meaning between two groups that could not talk to each other directly. We dressed the job in strategy language. But if you audit a product manager's calendar honestly (I have audited mine), translation is most of the hours.

I am not dismissing that work. Translation was scarce and it was valuable, and it is where the role's power came from. We were also the only people who could hold both sides at once, the technical constraint and the business case, in the same head. Product managers got a seat at the table because we operated the interface to engineering capacity, the scarcest resource in the building. For a long time we were the only ones who could actually get a product built.

Both of those things are ending at the same time. That is what this essay is about.

The layer dissolves

Agents speak both languages now. A model can read a merchant complaint, turn it into a spec, and turn the spec into working code. It can read the code back and explain to a CFO what it does and what it costs. The two crowds the product manager stood between are starting to talk directly.

I watch this from a specific seat. At Yuno we orchestrate 1,000+ payment methods across 190+ countries, and every one of them arrives through a provider integration that used to be weeks of squad work. With agentic engineering, writing that code is getting close to automatic. The code, it turns out, was never the hard part. The hard parts are the ones that were always hard: knowing which provider matters, certifying against reality, keeping the thing compliant with a different set of laws in every country you touch, and operating it at scale when the provider's sandbox lied to you.

The same shift reached my own artifacts. A one-pager on my team no longer ships as a document. It ships with a working prototype built on our real components and a business case with real numbers, and it changes the approval conversation completely: you argue with the thing, not about the thing. The spec used to be a promise. Now it is a demo.

None of this required a reorg or a memo to start happening. The translation work just quietly stopped needing us.

The three jobs left

So what do we pay product managers for now? Three things. They were always supposed to be the job; translation just crowded them out.

  1. Proving it worked. Shipping stopped being the finish line. Adoption, revenue, the decision to double down or shut down: the part of the job that starts after launch is becoming most of the job. We are moving product teams to be measured on outcomes instead of output, because output is exactly what agents made abundant.

  2. Building the argument as a working thing. The product manager becomes the person who makes the first version, with agents, in days. Partly because it is fast. Mostly because a working prototype is the highest-bandwidth argument that exists; nobody debates a paragraph the way they debate a screen they can click.

  3. Deciding what deserves to exist, and when to kill it. When building was expensive, prioritization was mostly logistics: what fits in the quarter. When building is cheap, prioritization is the whole game, and it runs on judgment about your specific customers and your specific market. A model has taste about everything in general and nothing in particular. And the harder half of this job is the second half. Cheap building means we will ship far more things than we can maintain, so the real skill is writing the kill criteria before launch: the number that, if we miss it, means we shut this down. Without that, abundance just fills the portfolio with zombie products. That deserves its own essay and it is the one I am writing next.

Inside Yuno we compress this into one line: agents do the volume, product owns the judgment.

And we changed the front door to match. AI proficiency is a formal interview stage for every product role we hire now. The day-one checklist for a new product hire includes an agent subscription before most other tools. That is not a perk. It is the assumption the whole role sits on.

The part nobody wants to say out loud

Two consequences follow, and I do not love either of them.

First, the role gets smaller in headcount and bigger in leverage. A product org built around translation needs many hands. A product org built around judgment needs fewer people, each carrying more surface, each closer to a general manager than to a ticket writer. That is a painful sentence for a lot of people who are very good at the old job, and pretending otherwise helps nobody.

Second, and this is the one nobody is talking about: we just removed the bottom rung of the ladder. Junior product managers learned judgment by doing volume. You wrote three hundred tickets and watched which ones died in the real world, and the taste we celebrate in senior product people was built on years of exactly the work agents now do. If agents do the volume, where does the next generation's judgment come from?

My current answer is ownership instead of artifacts. I am running this bet now: junior product owners on my team get a real surface with a real number attached from month one, and they build with agents from day one. Apprenticeship through documents is gone. Apprenticeship through owning something small and real is not. Ask me in a year whether it worked.

What I'm not sure about

This whole essay leans on one load-bearing claim: judgment is the moat. Agents do volume, humans decide. I repeat it, my industry repeats it, every AI keynote repeats it.

What I am not so sure about is whether that claim is analysis or comfort.

Models are starting to know your customers with a depth no product manager can match. They read every support ticket, every sales call, every churn signal. That is more customer contact than I have ever had. If taste is compressed exposure, models will develop taste, including about your specific customers.

If that happens, the last irreducible piece of the job might be accountability rather than judgment: a person whose name is on the outcome, who can be asked why, and who can be wrong in a way that matters. You cannot fire a model.

I would love to be wrong about this one. But I am rebuilding my own team around the bet either way, and I will write about what breaks.

Until then, an honest question, and I actually want answers. Look at your last week in product. How many hours were translation, and how many were judgment? What did you do that an agent could not have done?

That list is your job description now.