Speaker Notes

Build the Right Thing: Product Engineering (Part 1) — Kent C. Dodds, EpicProduct.engineer

As AI coding agents commoditize implementation details and accelerate execution, developers must shift from writing code to cultivating deep product judgment, validating real user problems, and building the right things.

AI Engineer · 55:19 · YouTube ↗

Talk · solo speaker  Beginner · concepts and product strategy

Highlights

6 clips · 10 min of 55 min
    • AI coding agents make learning specific framework implementation details unnecessary for experienced developers.
    • The ability to direct agents replaces manual coding of boilerplate and UI components.
    • Educators must shift from teaching syntax to teaching durable judgment and product skills.
    • AI acts like a homing device, making implementation execution trivial and leveling the playing field.
    • Because execution is easy, developers can hit many targets, but not all targets create equal value.
    • The key differentiator is identifying which valuable target is actually worth aiming for.
    • Unchecked AI agents can rapidly expand systems and propagate bad practices, leading to product bloat.
    • Fast prototyping can create superficially functional features that lack scalability and edge-case handling.
    • Taking personal operational ownership forces developers to build robust agent playgrounds.
    • Seeing users struggle with software in real-world conditions completely shifts how engineers design solutions.
    • Engineering judgment comes from marrying technical experience with genuine human issues.
    • A product engineer lives half in the technology and half in the customer's environment.
    • Asking users if they would use a feature results in polite compliments rather than honest feedback.
    • Avoid asking hypothetical future questions since nobody can accurately predict their future behavior.
    • Ask about past behaviors, existing workarounds, and what those workarounds cost in time or money.
    • Building high-scale architecture for an unproven product can waste vast amounts of capital and engineering time.
    • Launching a manual integration or two-week MVP allows teams to test the market without heavy upfront investment.
    • Project validation is crucial to ensure engineering effort aligns with actual user demand.

Questions this video answers

6 · every answer cites the moment it was said
01 Why is implementation skill becoming less important for developers? 2 sources · 10:54

AI coding agents are rapidly improving and commoditizing the execution phase of software development. As building to spec becomes cheap and automated, developers face a shift where simply writing code no longer differentiates their value. Instead, the primary challenge moves from figuring out how to build something to determining if it is actually worth building.

02 What defines a product engineer compared to a traditional developer or product manager? 2 sources · 21:31

A product engineer acts as a bridge by connecting a deep understanding of customer needs directly to technical choices. Rather than just blindly turning tickets into implementations like an agent, they take ownership of architecture, workflows, and system constraints. They live both in the technology and in the user's world to ensure the software actually solves real human problems.

03 Why do AI coding agents risk making software products worse if used carelessly? 2 sources · 18:41

AI agents lack the human judgment to push back on scope creep and will rapidly accelerate bad practices and system bloat throughout a codebase. Because agents execute instructions so quickly, they can easily build the wrong thing at high velocity without pausing to check edge cases or scalability. Developers must actively slow down and exercise systems thinking to wrangle agents and maintain product quality.

04 Why is making the right architectural choices so expensive to fix later? 2 sources · 25:58

Changing architecture later is expensive because of its broad impact on both the rest of the team and the user experience. Because rework introduces high friction and resource costs, hiring engineers who understand product context and make the right choices initially is much more efficient. Relying on good initial primitives prevents costly refactoring down the road.

05 How should I interview software engineers for product engineering roles? 2 sources · 32:31

You should avoid traditional coding tests that prohibit AI agents, as those do not evaluate real-world execution. Instead, interview candidates by discussing core problem discovery and the system implications that follow. This reveals whether they understand how to map user needs to robust system architectures.

06 What kind of questions should I ask users during early idea validation? 2 sources · 41:47

You should ask about past behavior, specific workarounds, and prior costs instead of fishing for compliments or asking hypothetical future questions. Since nobody can predict the future, understanding what users did previously reveals true pain points. Uncovering active workarounds provides strong evidence of a problem worth solving.

Section-by-section summary

11 parts

Existential crisis of coding in AI era

AI coding agents have evolved to surpass human speed in routine implementation, sparking an existential crisis for developers and educators. When syntax and framework mechanics are easily generated, traditional skill acquisition becomes obsolete. Developers must pivot toward higher-level judgment and durable skills rather than focusing on implementation details.

Choosing the right target over execution

As AI agents level the implementation playing field, execution becomes cheap and commoditized. The core engineering challenge shifts from hitting targets accurately to deciding which targets are actually worth pursuing. Since resources and user attention are finite, identifying high-value problems is the ultimate differentiator.

AI accelerates bad practices without oversight

While AI enables rapid prototyping, it defaults to producing unscalable code and inflating technical debt if left unchecked. Products can degrade faster when non-intentional features accumulate without rigorous system design. Developers must actively wrangle agents and maintain architectural boundaries to prevent systemic bloat.

Product engineers bridge users and code

A product engineer connects deep customer needs directly to technical decisions like data modeling, workflows, and failure modes. Unlike pure product managers, product engineers use technical expertise to define the smallest viable slice of a feature. Living partially in the customer's world ensures that technical solutions actually solve real human problems.

Architectural primitives dictate long-term success

Making early architectural choices requires deep product understanding because structural changes become exponentially expensive later. Selecting the right primitives ensures that future iterations and agent-driven updates remain stable and scalable. Investing in correct foundational architecture avoids costly migrations and system overhauls.

Designing systems to prevent user error

Drawing from Don Norman's insights on the Three Mile Island incident, user error is often a symptom of flawed system design rather than operator incompetence. As engineers, building robust systems and clear primitives ensures both human team members and AI agents succeed.

Hiring for product sense over coding tests

Evaluating product engineers requires assessing systems thinking and problem discovery rather than relying on isolated coding challenges. Furthermore, maintaining tight communication between product managers and engineers prevents siloed development and duplicated internal primitives.

Validating ideas by asking about past behavior

The Mom Test framework advises against asking users hypothetical questions or pitching your solution directly, as they will often just offer polite compliments. Instead, ask about specific past behaviors, existing workarounds, and actual costs to get genuine signals on whether a problem is worth solving.

Avoiding costly overbuilding through early validation

Teams often waste significant time and money engineering large-scale solutions for unproven ideas before ever talking to users. Matching technical investment to actual market validation allows teams to test hypotheses quickly with manual integrations before committing to heavy architecture.

Closing feedback loops with early prototypes

Putting early prototypes in front of users helps determine if your solution effectively addresses their pain points through the friction they are willing to endure. This contextual understanding enables product engineers to select the appropriate architecture and avoid building the wrong abstractions.

Technical expertise distinguishes product engineers

While product managers focus on the what and why, product engineers leverage deep system knowledge and available primitives to determine how a solution fits into the existing architecture. This distinct technical judgment is what makes product engineers resilient and difficult to replace with AI agents.

0:00 / 55:19
k play/pause · f fullscreen · m mute
n next · p previous clip · t highlights/full
< > slower/faster · / search what was said
  • Product Engineering4× · first 1:22

    The durable skill of connecting customer needs and product judgment to technical choices.

  • Smallest Slice1× · first 21:50

    The minimal usable portion of a feature built to deliver actual customer value.

  • The Mom Test6× · first 37:07

    A customer interview framework focused on asking about past behavior instead of pitching unvalidated ideas to get compliments.

  • Kano model1× · first 37:17

    A prioritization framework used to evaluate software changes and feature requests based on customer value.