All posts

Why Product Managers Are Becoming Builders: Lessons From Stripe, Whatnot, and Laurel

A Builder ships the first working version of an idea instead of just writing the spec for someone else to build. Here's how product leaders at Stripe, Whatnot, and Laurel describe the shift, what it costs when nothing structural backs it up, and what it actually takes to make it work.

A Builder is what people are starting to call the combined Product Manager, designer, and engineer role forming inside fast moving product teams. A Builder ships the first working version of an idea instead of just writing the spec for someone else to build.

That shift is already reshaping how product organizations run at Stripe, Whatnot, and Laurel. Here's how three of their product leaders describe it, what it costs when nothing structural backs it up, and what it actually takes to make it work.

For twenty years software had one real bottleneck. Engineering headcount.

If you wanted more features shipped, you hired more engineers. Everything else in the org chart got built around that constraint. Product Managers wrote specs. Designers made mockups. Engineers turned both into code.

That constraint just broke. And the people running product at the companies furthest along are saying so out loud.

The old way: Product, Design and Engineering handoff chain, bottlenecked on engineering headcount.

Generative AI collapsed the cost of writing code to almost nothing. A Product Manager with a laptop can now generate a working prototype before lunch, no ticket filed, no engineering queue. LinkedIn was one of the first to name this shift, folding product, design, and engineering into a single Full Stack Builder role.

That naming problem is already backed by hard numbers. The 2026 CPO Insights Report, a survey of more than 1,500 Chief Product Officers by Products That Count and Mighty Capital, found that what it calls Product Builders grew tenfold in a single year, while traditional Product Manager headcount fell 30% across industries and as much as 70% in SaaS specifically. The report notes that a single Product Builder can now do the work of about twelve specialists split across product, design, and engineering.

Builder roles up 10x while traditional PM roles decline, per the 2026 CPO Index.

But it's the practitioners actually living inside this shift right now who describe it best. And what they describe lines up closely with the exact problems Forge was built to solve.

"We regret that product management exists"

That's not a hot take from an outsider. It's Tom Verrilli, Chief Product Officer at Whatnot, describing the philosophy his team was built on from day one.

His argument isn't that Product Managers are worthless. It's that the specialist Product Manager function only earns its place when engineers and designers genuinely can't hold the full context themselves. Hiring one by default, just because a team hit a certain headcount, quietly weakens the muscle everyone else was building. Whatnot received 31,832 Product Manager applications over two years and hired a tiny handful, on purpose.

The problem underneath this

Knowledge that lives in one person's head.

  • Critical business logic often lives in two or three people's heads, not in any system.
  • Every change becomes a guess when that person is out, or leaves.
  • Roadmaps quietly stall waiting on the one person who understands why something works the way it does.

Verrilli's point is really that this pain gets worse the more you outsource judgment to a title instead of distributing it. The fix isn't fewer Product Managers or more Product Managers. It's making sure the context a good Product Manager would bring into the room doesn't live only in that one Product Manager.

Forge keeps that context shared across every team instead of locked in one inbox. When the spec shifts, Product, Design, and Engineering are all working from the same updated version, not three slightly different plans. No single person becomes the org's single point of failure.

When the one PM holding the context is out, Product, Design and Engineering lose it.

That's the exact gap a Living Spec is meant to close. It's also why a paused project resumes exactly where it left off, whoever picks it back up. Teams working from one shared spec this way have seen 60% fewer redos overall.

What does "everyone is a builder" actually mean?

That same observation shows up everywhere once you start listening for it.

At Laurel, the AI-native company behind a modern timekeeping product, CPO Jiaona Zhang described replacing the old Product Manager, designer, and engineer trifecta with something they call the captain model. Whoever is closest to the problem becomes the captain who owns an initiative end to end. That could be a Product Manager, an engineer, a customer success manager, or someone in legal. Everyone, in her words, is a product builder now.

Kevin Yen, who leads merchant experience at Stripe, framed the shift in almost identical terms on a separate conversation:

“It's not one function eating another. It's every function collectively moving over so that we can all actually get more done and deliver more impact.”

— Kevin Yen, Merchant experience, Stripe

He also made a point worth sitting with. A lot of the Product Manager job going forward stops being about using static tools to ship a feature. It starts being about building the system that builds the product.

The problem underneath this

Losing sight of what actually got built.

  • The moment a build gets handed off, or handed to an agent, the person who owned the intent loses the thread.
  • There's no real insight into what actually got built or decided until launch day.
  • By then it's too late to course correct cheaply.

Stripe's answer was a shared knowledge repository, so an agent answering a question carries the same context and judgment a Product Manager would have brought to that conversation, not just a raw transcript of what customers said. It's a smart workaround.

Forge builds that same idea into the platform itself. An agent working inside Forge doesn't just get a task description. It gets the full intent pulled straight from the Living Spec, so what gets built matches what was meant, not just what was literally asked.

Intent, architecture and compliance carried from Living Spec to Work Order to agent session to deployed build; ~98% faster spec generation.

In an eight week enterprise pilot, spec generation ran roughly 98% faster this way, with ideas reaching a deployed build in hours instead of weeks.

Yen's line about building the system that builds the product is basically the founding premise behind Forge too, a theme the Forge blog keeps coming back to. Nobody has to reconstruct intent after the fact, because it never left.

Three different companies. Three different product leaders. Converging on the same idea from different angles. The Builder role isn't a trend piece. It's already how these teams operate.

Why didn't speed alone fix the problem?

Here's where it gets interesting, because none of these leaders are describing a free lunch.

Jiaona Zhang was candid about what happens once everyone can ship. Without some kind of structure, letting anyone touch anything in the codebase produces what she called a Frankenstein, fast.

Laurel's answer wasn't to slow people back down. It was to treat the codebase like a garden.

The codebase as a garden: know which part you're standing in.

The rule that made all of it work wasn't "move fast." It was making sure everyone knew, at any given moment, which part of the garden they were standing in.

Two problems show up here at once: specs that drift, and compliance issues that surface late.

Specs that drift

  • The PRD gets approved. Six sprints happen.
  • What actually ships looks nothing like what anyone signed off on.
  • It's rarely one dramatic failure. It's a slow accumulation of small undocumented decisions.

Compliance issues that surface late

  • HIPAA, SOC 2, and PCI issues show up after code ships, because nothing checked policy at the moment the code was generated.
  • Each finding adds weeks to a release that was supposed to take hours.
Spec drift is a slow accumulation across sprints, not one event.

Work Orders are what actually enforce that garden at the platform level. Every agentic action a Builder takes gets authorized against a human auditable Work Order tied back to the original spec, so nobody has to guess which bed they're allowed to plant in.

Compliance policy attaches at the same moment. Industry presets for HIPAA, PCI-DSS, SOC 2, and GDPR get built into the spec before generation even starts, instead of getting reviewed in after the fact. Teams working this way have seen zero architectural drift and 66% of rework eliminated.

For teams sitting on years of legacy code rather than a tidy garden already, ForgeScore maps the existing codebase across eight health dimensions in minutes, so a team knows which parts are stable ground before anyone starts building.

The rework nobody budgeted for

There's one more problem worth naming on its own, because it shows up regardless of which company you ask: constant rework.

Without a real plan behind them, AI coding tools average three to four retries to get a task right. They guess at requirements and relearn the same system context every time, because nothing persists between sessions.

One team saw this play out directly with an autonomous coding agent. Three features shipped in two months, all technically working. Then a fix was needed, and it took five days just to understand the unfamiliar pattern the agent had chosen on its own. The review gate was a pull request after the fact, not a plan agreed on up front.

Same agents; the one with a governed plan needs far fewer retries.

On that same benchmark, agents working without a governed plan needed an average of 3.2 tries to get a task right. Once the same agents had a plan generated by Forge to work from, that dropped to 1.3, roughly where the 60% reduction in redos, and the accompanying drop in token spend, comes from.

Why don't the obvious fixes work?

The instinct is to reach for more of what already exists. Here's how each option actually holds up.

ApproachWhat it does wellWhat it misses
Hiring more engineers or Product ManagersAdds real capacityAdds another layer of people who have to re-explain intent to each other
AI assistantsFast, capable first draftsNo memory between sessions, no check against architecture or compliance
Autonomous coding agentsCan execute a full task inside one sessionThe plan lives inside that session, not a persistent, inspectable artifact
Bolt-on compliance toolingCatches real, valid issuesOnly catches them after the code is already written
Building governance in houseFull control, tailored to the orgYears of engineering investment before a single feature ships
A governed system like ForgeSame AI speed, with the plan and the compliance policy attached from the first specRequires rethinking process, not just adding a tool

Different tools, same missing piece across the first five rows. None of them carry governance with the work by default. They bolt it on, or they skip it entirely.

Why can't this wait?

Every leader in these conversations was describing something already happening inside their org today, not a future state they were planning toward.

The Builder shift already occurred. The real question left for most companies is whether there's a system underneath the Builder that remembers what was actually approved, so speed and accountability stop being a tradeoff.

For companies in regulated spaces, that question has a shorter runway than it used to.

  • HIPAA, SOC 2, and PCI requirements that once only applied to later-stage companies are showing up earlier, especially for teams in regulated industries like healthcare.
  • A missed finding today doesn't just cost a sprint. It can cost a renewal, or an uncomfortable board conversation.
  • Teams generating code ten times faster are still losing something like 40% of their software budget and half their cycle time to manual review and rework a governed plan could have caught up front.
The cost of standing still, paid every sprint whether you decide or not.

Standing still isn't neutral. It's an ongoing cost, paid every sprint, whether or not a team has decided to do anything about it.

Why Forge makes sense for the next generation of Full Stack Builders

LinkedIn's Full Stack Builder framing was the right call, but naming a role doesn't hand anyone the infrastructure to work that way. Someone wearing product, design, and engineering at once doesn't have a dedicated ops team quietly keeping architecture and compliance consistent behind them, so whatever tooling they use has to carry that weight itself, or they inherit it personally.

That's what Forge is built to be underneath this next generation. Not another tool to learn, but the layer that makes working as one person across four functions survivable at production quality.

  • Product Manager acting as Full Stack Builder. What you approved is what ships, even six sprints later. Teams working this way have kept zero architectural drift while running spec generation about 98% faster in an enterprise pilot.
  • Product Designer. Design systems become part of the Living Spec itself, so what ships matches what was actually designed, not someone else's read on it.
  • Technical Program Manager. Every agent action already runs through a human auditable Work Order, so nothing needs reconstructing after the fact.
  • Head of Product or CPO. The question stops being whether Builders can move fast, and becomes whether that speed is repeatable and provable. One eight week pilot validated 15 of 15 use cases, with business teams confirming 80 to 90% of the results.

The next generation of Builders won't look like today's Product Manager, designer, and engineer trio stitched together with standups and handoff docs. They'll look like Verrilli's captains, or Jiaona Zhang's gardeners, one person, carrying real context, building fast, provably. Forge is the infrastructure underneath that person, so the role LinkedIn named actually has somewhere to stand.

Where this leaves Builders

None of the product leaders quoted here are arguing against speed. They're describing what it actually takes to keep speed and accountability in the same room, whether that's a garden metaphor, a captain model, or a living knowledge base that updates itself.

That's the exact problem Forge was built around. It lets a Builder move at AI speed without losing control of what gets built. Every session inherits the same intent, and every line of code traces back to an approved spec.

Original intent, architecture decisions, and compliance requirements travel with the build from the first spec all the way through deployment. Nothing quietly drifts the way Verrilli, Yen, and Jiaona Zhang all described watching happen without it.

Teams working this way have seen 66% of rework eliminated and delivery run 83% faster, with zero architectural drift along the way. That's roughly the outcome each of these leaders was hand building toward with Slack tools, gardening rules, and hiring discipline, before this kind of tooling existed natively.

It does now. If you're weighing this shift for your own team, the fastest way to see it is to book a demo and walk through how a Living Spec would handle your next sprint.

Two people at work on code, seen from behind their monitors.

See it running on your own pipelines.

Forty-five minutes with our engineers. Bring a pipeline you are unhappy with.