Product leverage
The collapse of product and engineering.
The role of product management is not disappearing. But the leverage is shifting away from shaping decisions at a distance and toward judgment, creation, and direct ownership of outcomes.
In this piece
~9 min read · ~2 min skim (highlights & visuals)
Why the separation between deciding and building is collapsing
Why judgment is becoming the real constraint
What actually creates leverage now
The shift
The role didn’t change when the title did.
It changed before anyone realized it.
The role of product management is not disappearing, but the center of gravity has moved. For a long time, leverage came from helping teams decide what should happen, translating that decision into specs, and aligning execution across functions. That work mattered because building was expensive and misalignment was costly. But as the cost of building drops and iteration cycles compress, alignment alone stops being the scarce skill. The leverage shifts to the people who can decide what is worth making real in the first place, and then follow that decision all the way through.
The Old Model
Product management wasn’t about building.
It was about aligning the people who did.
PMs framed problems, aligned stakeholders, wrote specs, and sequenced work. Engineering built. Design supported.
That structure existed for a reason. Building was expensive. Even small changes required multiple people, careful planning, and alignment across teams. You couldn’t just try things, you had to get them right before you started. So the system optimized for alignment.
PMs became the glue. They translated ideas, connected teams, and made sure nothing broke between handoffs. It worked. Until it didn’t.
Alignment used to be the job. Now it is overhead.
What Changed
That model didn’t evolve.
It broke.
First, building got cheap. You can go from idea to working prototype in hours, not weeks. What used to require multiple teams can now be done by one person with the right tools.
Second, alignment work is getting compressed. Docs, summaries, and breakdowns are being automated. The work that used to justify layers is disappearing.
Third, iteration speed increased. You no longer need to debate for weeks to move forward. You can test something quickly, see what happens, and adjust.
Taken together, this changes where risk lives. It’s no longer in execution. It’s in the decision itself.
Before
- Write a spec
- Align across teams
- Wait for a build cycle
- Ship weeks later
Now
- Form a point of view
- Build a version
- Put it in front of users
- Adjust immediately
The distance between deciding and building is collapsing.
That shift changes who actually creates value. Teams that still operate the old way break.
They spend days aligning on decisions that could be tested in hours. By the time they ship, the context has already changed.
Meanwhile, smaller teams move faster with better outcomes. Not because they are working harder, but because they are closer to the decision.
The New Constraint
Execution stopped being the bottleneck.
Judgment replaced it.
Those decisions always mattered, but they didn’t always determine the outcome. Strong execution could compensate for weak judgment. That’s no longer true.
When execution is fast and cheap, the quality of the decision becomes the dominant variable. Bad decisions don’t get smoothed over, they get amplified.
What is worth building? What tradeoffs matter? What actually moves the business?
Execution is abundant.
Judgment is not.Speed does not fix bad decisions. It amplifies them.
What Judgment Looks Like
Frameworks don’t make decisions.
People do.
It’s deciding which part matters most, what to remove versus add, how something will impact behavior, and what success actually looks like in practice.
Anyone can say, “we should improve onboarding.” Very few people can decide:
- which part matters most
- what to remove versus add
- how it impacts retention, support, and behavior
- what success actually looks like
Same team. Same velocity.
Different decisions. Different outcomes.
On the other side, small changes create outsized impact: a better default, a removed step, a clearer flow.
Not because execution improved. Because judgment did.
The Parenting Analogy
Anyone who has set a rule knows this.
Setting rules is easy:
- "Bedtime is 8:30."
- "No screens after dinner."
- "Do your chores when you wake up."
- "Treat others the way you want to be treated."
That’s the plan.
The hard part is applying it when they are tired, when plans change, or when they push back. The situation gets messy, and the decision needs to adapt without losing intent.
Product decisions work the same way. It’s easy to define what should happen. It’s much harder to apply that decision consistently in real conditions.
That is judgment.
The New Model
Deciding and building used to be separate.
They aren’t anymore.
The loop replaces the pipeline.
This compresses the distance between intention and outcome. It also removes the illusion that decisions can be isolated from execution.
Instead of handing decisions off to be executed, the same person or team moves through the full cycle, forming a point of view, making it real, exposing it to reality, and adjusting based on what they learn.
Decision loop
Form a point of view
Make it real
Expose it to reality
Adjust and repeat
decision → artifact → feedback → decision
The loop is the job now.
The highest leverage people stay inside that loop. They do not stop at deciding. They do not wait for handoffs.
They turn ideas into something real, see what happens, adjust, and repeat.
This is the kind of loop I have built and operated inside.
Not just defining decisions, but pushing them all the way to outcomes.
What this changes
If you’re still optimizing for alignment at a distance, you’re already behind.
If your value is aligning execution at a distance, you lose leverage.
If your value is judgment, you gain it.
They form strong opinions from real signals, make ideas tangible quickly, understand the system beyond individual features, and stay accountable to outcomes.
In practice, this means building and testing instead of writing specs, validating directly instead of debating, and shaping systems instead of optimizing isolated features.
Cycles shrink. Decisions improve. Not because everything is perfect, but because it is grounded in reality.
PMs who only align and hand off decisions lose leverage. If your value is writing specs and aligning teams, you are competing with tools.
Engineers move closer to product decisions. Design splits between production work and taste or system-level thinking. The boundaries blur. The work gets recombined.
What a Modern PM Looks Like
This is what the role actually looks like now.
In practice
Instead of writing specs, build and test. Instead of debating, validate directly. Instead of optimizing features, shape systems.
I have seen this shift firsthand. Teams move from “discuss and hand off” to “decide and build.” Cycles shrink. Decisions improve.
Not perfect, but grounded in reality.
What Happens to PMs Who Do Not Build
If judgment is the constraint, most organizations are designed wrong.
They move into alignment-heavy roles or become dependent on others to execute their decisions. That dependency creates distance from the outcome.
This is not about becoming an engineer. It’s about reducing the gap between deciding and building. If you cannot turn a decision into something real, you are always one step removed from what actually happens.
That dependency creates delay at every step.
Implications for Organizations
If judgment is the constraint, the organization must reflect it.
Systems that reward alignment at a distance will slow down. Systems that enable tight decision loops will compound over time.
I have seen this most clearly in execution systems. When ownership is clear and feedback loops are tight, teams move faster, issues resolve quicker, and decisions improve.
When decisions are abstracted, everything slows down, even with more people.
Closing
This isn’t a role debate.
It’s a shift in where value is created.
Value used to come from shaping decisions and aligning teams to execute them. Now it comes from forming judgment and turning it into reality.
The people with the most leverage can do both.
Form judgment.
Make it real.
Learn.
Adjust.
Everything else is downstream of that, including the roles themselves.
The role is not disappearing.
But the leverage has already shifted.
And the people closest to that loop will define what gets built.
Most teams have not caught up yet.
If you are building in this shift
If this resonates, this is the work.
Not more process. Not better specs. Not tighter coordination. Better judgment, faster loops, and closer contact with reality.
Pass it to someone building in this shift.