The New Product World

Think back to two months ago.

If you're at a corporation: your product org was humming along. Sprint planning on Monday, backlog refinement on Wednesday, design reviews on Thursday. Jira boards with neat columns. A roadmap that looked three quarters out. It all felt solid. Permanent, even.

If you're at a smaller software house: specs in Linear, light prototyping, quick estimates, shipping in weeks. As a PM you were copy-pasting through AI tools and calling it an AI workflow.

I need to tell you what I'm seeing now. Not the polite version. Not the “AI is a great tool for PMs” version. The real version. The one that sounds like I've lost my mind until you actually sit down with Claude for an afternoon and realize: this is what computers were always supposed to do for us.

The role domains are collapsing. Fundamental product principles are shifting. Not slowly. Not incrementally. And it's accelerating, every month faster than the last. You're not going to have time to breathe as a PM and adapt gradually. This is a tectonic shift. Welcome to the new product world.

The trigger

In early 2026, new AI models dropped. Especially Opus 4.6 from Anthropic, alongside Claude Cowork, which connects directly to your entire workflow. And something broke. Not the models. The org chart.

Here's what actually happened. I looked at Claude's 50+ connectors (Linear, GitHub, Sentry, Gmail, Google Drive, Amplitude, Excel) and realized that 90% of what a PM needs is already wired in. Then I used Opus 4.6 itself, and I was amazed. It's not guessing anymore. It asks to clarify when something's unclear. It runs agents. It codes. It produces artifacts: interactive HTML wireframes, working apps, managed deploys.

Then Cowork. Finally something easy enough for everyone to understand. You drop the prompt, attach files like call transcripts, give it context, and it runs. The quality of output is consistently high, and it scales.

And the price? $20 a month. Any PM can afford that. We finally have a tool that only needs your product context. The execution is done by AI. Fast, high-quality, consistent, scalable.

You've probably read that engineering is changing. The truth is that the SDLC is collapsing. Agents writing code, tests, deploying, all in one loop. That's real. But it's only half the story. The engineering lifecycle didn't collapse in isolation. It took the entire product function down with it. Every role that existed to manage the gap between “what should we build” and “the thing is built” is getting compressed into nothing. Because the gap is gone.

The roles are collapsing

Let me walk you through it.

Scrum Masters and Agile Coaches

I'll say it plainly: these roles are already redundant. There are fewer people in the workflow to manage, and soon there'll be fewer still. What you need now is an efficient context framework and infrastructure for AI agents. The human coordination layer is leaving the game.

Sprint planning, story points, velocity charts, retros. All of it was invented to manage human workflows and coordination when building was expensive, inefficient, and slow. When agents can ship five versions of a new feature in an afternoon, you don't need a two-week sprint. You don't need a planning ceremony. You don't need someone facilitating a standup. The entire Agile, Scrum, SAFe apparatus was a solution to a problem that no longer exists.

Trust me. I'm a certified Scrum Product Owner, PSPO, SAFe PM. All useless frameworks and certifications by now. If you're early in your career, don't build on this foundation.

Product Owners / Junior PMs / Backlog Managers

If your job was taking customer or stakeholder requirements, writing them into tickets, and feeding them into a pipeline for engineers, that's a workflow. Workflows get automated. The PO role, the backlog groomer, the person who translates business needs into Jira stories: that layer is compressing so fast it's hard to watch. Agents consume context directly. They don't need your translation. They need your judgement, and if you don't have that yet, the ticket-writing isn't going to save you.

The one upside? The endless confusion about “product manager vs. product owner” will finally be buried. It was irrelevant five years ago. It's nonsense to even think about it now.

Designers

This one hurts because I have some really good friends among them. But let's be honest about what's already gone. Wireframing, UI design, prototyping: agents do all of it now, end to end. You iterate on the real thing, not a picture of the thing. The production layer of design is already redundant. What survives is taste. The ability to look at what an agent built and know it's wrong before you can explain why.

But the bigger shift is this: the product trio is dead. PM, designer, engineer. Three roles, three handoffs, one unit. For a decade we organized around this holy trinity. That model assumed these were fundamentally different disciplines requiring fundamentally different people. That assumption just broke. When a PM can get a working, designed prototype from an agent in five minutes, and a designer can do the same, and an engineer can do the same, the domain walls collapse. You don't need three people triangulating toward a solution. You need one person with clarity and taste, and agents that execute.

Engineers

This is the role that felt it first. The agent writes the code, the tests, deploys. The SDLC didn't just get faster; the stages merged into a single loop of intent, context, and iteration. Engineers who started after Cursor launched have never estimated story points, never waited three days for a PR review, never sat through sprint planning. They just build things. Free from the ceremony.

The role didn't disappear. It mutated. The job shifted from writing code to orchestrating agents that write code. From implementer to orchestrator. The new core skill isn't coding. It's context engineering: knowing which information the agent needs to produce the right output.

What matters for PMs is this: the bottleneck didn't just move away from engineering. It evaporated from engineering and landed squarely upstream, on you. The engineer's constraint used to be your constraint. You couldn't ship faster than they could build. That speed limit is gone. Now the only constraint is whether you actually understand what's worth building.

Product Managers

Here's where it gets complicated, because I'm one of us. Parts of our jobs are already redundant. The translation layer (understanding the customer and converting that into specs for engineers) is gone. Same as engineers became multi-domain, you will too. AI will cover the gaps in design or engineering knowledge you don't have.

But here's what nobody's talking about yet: the PMs who figure this out won't just survive. They'll be more powerful than any PM has ever been. You'll go from “I think we should build this” to “here, I built three versions, this one tested best” in an afternoon. No handoffs. No waiting. For the first time, the person closest to the problem will also be the person who ships the solution. That's not a smaller role. That's the role PMs always wanted but never had the tools for.

What actually matters now

Here's the fundamental truth that hasn't changed: the product is just a vehicle for value. What's changed is that the vehicle is now absurdly cheap to build. And when building is nearly free, knowing what to build is the only thing that matters.

The bottleneck moved upstream. Way upstream. It's not engineering capacity anymore. It's not sprint velocity. It's not designer bandwidth. It's you. You need to build the whole agentic framework: with the right context, directing with the right intent, and taste. You'll be the last human in the software. The last inefficient link in the chain. There is no alternative. If you don't adapt, your company won't survive.

What you should do

If you're a PM reading this:

The bigger picture

Every industry is about to go through what product teams are going through right now. The bottleneck shifts from execution to judgement. From building to deciding what to build. From “can we do this?” to “should we?”

Product management isn't dead. But product management as a workflow, as a set of ceremonies, tools, and handoffs, absolutely is. And the product trio (PM, designer, engineer as separate disciplines) is fusing into one.

What's left is everything that actually mattered all along.

Understanding the problem. Human empathy. Judgement. Taste.

The rest was overhead. And the agents just made that obvious.