The End of the Handoff: How AI is Blurring the Lines Between Product, Design, and Engineering

On a recent episode of Lenny's podcast, LinkedIn's VP of Product Tomer Cohen shared something that's been quietly happening across the tech industry: product managers are learning to code. Not to become engineers, but to validate ideas faster.

But here's what I find interesting: this isn't just about PMs changing. It's not even mainly about PMs. The real story is that the boundaries between product, design, and engineering are starting to blur. These boundaries made sense for decades, but that's changing.

This piece is for product leaders, designers, and engineers who feel their teams are moving faster than their processes, and suspect the bottleneck isn't skill, but coordination. This isn't about replacing specialists or turning everyone into hybrids. It's about reducing the cost of learning between specialists.

Why Handoffs Existed in the First Place

The PM → Designer → Engineer workflow wasn't arbitrary. It emerged because experimentation was expensive.

Building a prototype used to require:

• Hours of design work in Sketch or Figma
• Days of frontend development
• Backend infrastructure to make it functional
• QA to make sure it didn't break

When each experiment costs days or weeks, specialization makes sense. You hire people who are really good at their specific part of the process, and you hand work between them. The cost of coordination was annoying, but it was less than the cost of having everyone be mediocre at everything.

The equation was simple: Cost of handoff < Cost of execution

So we accepted the handoffs. We built processes around them. We hired specialists. We created role definitions that reinforced the boundaries.

What AI Changed: The Cost Collapse

AI didn't just make coding faster. It collapsed the cost of experimentation across all three domains simultaneously.

A product manager can now:

• Prototype a production-grade UI with AI-assisted coding in an afternoon
• Generate realistic mockups with AI image tools
• Build a working demo with AI pair programming
• Test it with real users by Friday

A designer can:

• Generate code from design files automatically
• Build interactive prototypes without engineers
• Test different interaction patterns in hours

An engineer can:

• Scaffold entire features with AI assistance
• Explore design alternatives in code
• Ship end-to-end without waiting for specs

The equation flipped: Cost of handoff > Cost of execution

When you can prototype an idea in an afternoon, waiting three days for a design handoff becomes the bottleneck. The coordination overhead now exceeds the execution cost.

The fundamental shift: When experimentation becomes cheaper than coordination

LinkedIn's Proof Point

LinkedIn recently replaced their Associate Product Manager program with something called Associate Product Builder. The new program teaches code, design, and product together. Not sequentially, but simultaneously.

This isn't because LinkedIn thinks PMs must become engineers. It's because they recognized something fundamental:

What I'm seeing: the velocity of learning can now exceed the velocity of delivery

As Tomer Cohen, LinkedIn's Chief Product Officer, explains: the old model created "organizational bloat" that stretched feature development to six-month cycles. Meanwhile, the World Economic Forum estimates that 70% of the skills needed for jobs will change by 2030. The traditional approach of hiring specialists and coordinating handoffs doesn't work when the skills themselves are shifting that fast.

When anyone on the team can prototype an idea in hours, the bottleneck shifts from "who can build this?" to "who can figure out what's worth building?" The ability to think, validate, and iterate quickly matters more than deep specialization in one domain.

Three Manifestations of Convergence

This shift is playing out differently across the three disciplines, but the pattern is the same: roles are expanding toward each other because the friction that kept them separate is disappearing.

Product Managers → Hands-On Validators

Product managers used to write specs and wait. Now they're prototyping their own ideas.

This doesn't mean PMs are becoming engineers. It means they're removing the friction between "having an idea" and "testing if it works." They're using AI tools to:

• Build rough prototypes to test assumptions
• Validate ideas before involving the full team
• Ship small features independently
• Understand technical constraints deeply enough to make better product decisions

The role is shifting from coordinator to validator. From writing what should be built to showing what could be built.

Designers → Autonomy Architects

What I find most interesting is the shift in design. When AI does things for users instead of with users, the designer's canvas expands beyond screens.

Traditional UX: Design the interface for user actions.

AI-powered UX: Design the boundaries of system autonomy.

Designers are spending less time on "what should this button look like" and more time on:

• What should the system handle automatically?
• When should it ask for permission?
• How much control should users retain?
• How do we show what the AI is doing?

For example: deciding whether an AI should auto-approve expenses under €50, ask for confirmation, or surface a recommendation instead. That's not a UI decision. It's a system behavior decision. It requires understanding user trust, error tolerance, and the consequences of getting it wrong.

These aren't interface questions. They're system behavior questions. They blend design thinking with product judgment and require understanding how the technology works.

The discipline is expanding from visual design toward product thinking and technical understanding.

Engineers → High-Leverage Problem Solvers

Meanwhile, engineers are being freed from boilerplate to work on harder problems.

AI handles the known patterns: CRUD endpoints, form validation, standard component structures. This doesn't eliminate junior engineers. It changes what they learn. Instead of memorizing syntax, they're learning judgment: which patterns apply, when to deviate, how to evaluate tradeoffs.

Senior engineers remain valuable for the same reason they always have: recognizing patterns across contexts, avoiding costly mistakes, and solving novel problems that don't have established solutions.

But both junior and senior engineers are increasingly making product and design decisions inline, because the cost of checking with someone else is higher than the cost of trying something.

The flip side is that product and design decisions are now made more locally, sometimes invisibly. This raises the bar for judgment, not lowers it. An engineer who ships a feature because "it worked" may have embedded UX assumptions or product tradeoffs that were never discussed. Speed creates new risks alongside new capabilities.

How the three disciplines are expanding toward each other

What This Means for Teams

If your team is still organized around handoffs, you're optimizing for a cost structure that no longer exists. This shows up not just in workflows, but in team topology, approval paths, and role definitions that assume work must move sequentially.

The new reality:

• Faster learning cycles – Ideas can be tested in hours instead of weeks
• Less coordination overhead – One person can often validate an idea end-to-end
• More collaboration, less handoff – Working together replaces passing work between silos
• Blurrier boundaries – Specialists still exist, but the edges of their roles overlap more

This doesn't mean everyone becomes a generalist. Deep expertise in product thinking, design craft, or engineering architecture still matters. But the friction between disciplines is low enough that individuals regularly cross boundaries.

The shift is already happening. Teams at companies like Airtable and Runway are using AI coding assistants and language models to draft PRDs, prototype features, and generate documentation. Team members are becoming what Salesforce Ventures research calls "generalists"—handling revision, strategy, and critical thinking while AI manages repetitive tasks. The work isn't disappearing. It's being redistributed toward higher-value activities.

The Modern Product Builder

The most effective people in product development are developing competence across all three domains: product judgment, technical understanding, and AI-assisted prototyping.

Not expert-level in all three. But capable enough to validate ideas without waiting for handoffs.

The key insight: AI doesn't replace judgment. It amplifies it by removing the friction between thinking and testing.

AI gets work to "80% fidelity." The human contribution is refining that final 20%.

As product leaders at companies like Airtable and DataRobot have observed, AI gets work to "80% fidelity." The human contribution is refining that final 20%. That 20% is where judgment lives: understanding user needs, recognizing patterns, making tradeoffs, deciding what matters.

Someone with strong product instincts and basic technical skills, augmented by AI, can now do what used to require a full team. They can think through a problem, prototype a solution, test it with users, and iterate. All in the time it used to take to schedule the kickoff meeting.

Try This Next Week

Want to test these ideas with your team? Start small:

The Question Ahead

The disciplines aren't disappearing. Product thinking, design craft, and engineering expertise all remain valuable. But the boundaries between them are becoming more like gradients than hard lines.

The teams that adapt fastest will be the ones that recognize this: when experimentation is cheap and coordination is expensive, you optimize for learning, not for handoffs.

I don't think the question is whether to embrace this shift. It's more about finding the pace that works for your team and context.

---