Linear, Flint Founders Say AI Shifts Software Race from Code to Taste
The Pragmatic Engineer
As AI background agents commoditize routine code generation, engineering teams must anchor their edge in craft, design polish, and direct customer exposure to avoid product degradation.
Product engineering replaces rigid front-end/back-end silos with end-to-end user ownership, defining roles by a focus on 'what' and 'why' rather than merely 'how'. (2:21)
In AI-native workflows, engineers run multiple background coding agents concurrently for micro-fixes while designers ship production-ready preview builds directly via Claude. (24:00)
Evaluating and cultivating engineering 'taste' relies on practical simulation and company rituals—such as Linear's 'Quality Wednesdays', which resolved 2,500 subtle UI defects over two years. (21:37)
Engineering metrics must evolve past vanity metrics like sign-ups or time spent toward counterfactual value questions that gauge true product indispensability. (31:13)
Detailed notes
## Background
Published on YouTube by The Pragmatic Engineer on March 22, 2026, this panel session from The Pragmatic Summit brings together Tuomas Artman (co-founder of Linear), Michelle Lim (co-founder of Flint), and Drew Hoskins (author of The Product-Minded Engineer). Moderated by MA from Statsig, the discussion centers on defining the product engineer archetype, cultivating design taste, and operating effectively in an AI-native engineering environment.
## TL;DR
The panel defines product-minded engineering as caring deeply about the 'what' and 'why' rather than just the 'how,' emphasizing that even backend infrastructure and code interfaces function as products with human users. The speakers detail concrete organizational rituals for building taste and quality, such as Linear's 'Quality Wednesdays' defect hunts, Stripe's narrative developer flow reviews, and paid week-long work trial interviews. They also explore how AI workflows are fundamentally transforming software development by enabling multi-agent background triage, collapsing customer feedback loops, and allowing designers to ship functional pull requests directly. In conclusion, the panelists urge engineering organizations to maintain direct, human customer exposure, measure counterfactual value instead of vanity metrics, and grant engineers dedicated space to defend product craft.
## Atmosphere & style
The panel maintains a collegial, candid, and pragmatic tone, blending relaxed humor with rigorous technical craftsmanship. Rather than leaning on vague AI hype, the speakers exchange grounded war stories from Uber, Stripe, Linear, and early-stage startups, creating a reflective and collaborative dynamic. It feels like an authentic peek into senior industry leaders dissecting their own workflow shifts and passionately defending the often-overlooked micro-details of user experience.
## Bulletin
- [02:21](https://www.youtube.com/watch?v=0Cv5763UX70&t=141s) Product engineering replaces rigid front-end/back-end silos with end-to-end user ownership, defining roles by a focus on 'what' and 'why' rather than merely 'how'.
- [24:00](https://www.youtube.com/watch?v=0Cv5763UX70&t=1440s) In AI-native workflows, engineers run multiple background coding agents concurrently for micro-fixes while designers ship production-ready preview builds directly via Claude.
- [21:37](https://www.youtube.com/watch?v=0Cv5763UX70&t=1297s) Evaluating and cultivating engineering 'taste' relies on practical simulation and company rituals—such as Linear's 'Quality Wednesdays', which resolved 2,500 subtle UI defects over two years.
- [31:13](https://www.youtube.com/watch?v=0Cv5763UX70&t=1873s) Engineering metrics must evolve past vanity metrics like sign-ups or time spent toward counterfactual value questions that gauge true product indispensability.
## Key takeaways
- [02:21](https://www.youtube.com/watch?v=0Cv5763UX70&t=141s) A product engineer acts as a full-stack builder with product management instincts sprinkled on top, prioritizing problem discovery and user needs over pure code complexity.
- [02:21](https://www.youtube.com/watch?v=0Cv5763UX70&t=141s) Product mindset applies equally to internal infrastructure and APIs because interfaces must be discovered, understood, and safely consumed just like graphical user interfaces.
- [05:24](https://www.youtube.com/watch?v=0Cv5763UX70&t=324s) Traditional bifurcations between front-end and back-end engineering often misplace engineers, detaching them from either deep problem solving or real user feedback.
- [09:45](https://www.youtube.com/watch?v=0Cv5763UX70&t=585s) Linear leveraged extreme implementation and conceptual quality as its competitive wedge to outcompete well-entrenched incumbents in the project management space.
- [12:26](https://www.youtube.com/watch?v=0Cv5763UX70&t=746s) Product taste is not an inborn mystical trait; it is a learnable craft of 'shoe-shifting' that requires selectively forgetting implementation details to simulate the user experience from first principles.
- [12:26](https://www.youtube.com/watch?v=0Cv5763UX70&t=746s) Evaluating candidate taste in interviews is best achieved through paid week-long work trials or technical design problems constrained by authentic user journeys.
- [15:38](https://www.youtube.com/watch?v=0Cv5763UX70&t=938s) Default AI code generation gravitates toward generic aesthetic tropes, making human engineering taste the primary differentiator in crowded markets.
- [19:14](https://www.youtube.com/watch?v=0Cv5763UX70&t=1154s) Mandating 'developer flows' and narrative user stories in API reviews turns technical validation into self-debugging, exposing design flaws before review meetings occur.
- [21:37](https://www.youtube.com/watch?v=0Cv5763UX70&t=1297s) Linear's 'Quality Wednesdays' established a recurring ritual where engineers find, fix, and demo non-critical visual defects, sharpening team perception of micro-interactions.
- [24:00](https://www.youtube.com/watch?v=0Cv5763UX70&t=1440s) AI tooling enables multi-agent parallelism, where engineers direct background agents to triage customer feedback and resolve bugs within hours of detection.
- [26:19](https://www.youtube.com/watch?v=0Cv5763UX70&t=1579s) AI-assisted denoising of customer feedback loops across calls, tickets, and Slack prevents product engineers from becoming overwhelmed by raw inbound volume.
- [28:41](https://www.youtube.com/watch?v=0Cv5763UX70&t=1721s) The near-zero marginal cost of AI code generation enables designers and product managers to bypass engineering backlogs and ship functional preview builds directly.
- [30:27](https://www.youtube.com/watch?v=0Cv5763UX70&t=1827s) Automated summaries cannot substitute for direct human-to-human contact; having engineers join live customer sales calls and site visits builds irreplaceable empathy.
- [31:13](https://www.youtube.com/watch?v=0Cv5763UX70&t=1873s) Product metrics should progress along a gradient from vanity stats and time spent to meaningful interactions and counterfactual value questions.
- [32:27](https://www.youtube.com/watch?v=0Cv5763UX70&t=1947s) Engineering management must deliberately protect time for craft and defect resolution, as cumulative UI degradation cannot be fixed solely through short-term A/B experiments.
## Detailed walkthrough
### [00:00](https://www.youtube.com/watch?v=0Cv5763UX70&t=0s) Panel Introductions and Origins
The session opens with moderator MA, head of product and design at Statsig, welcoming the audience and joking that it is an honor people chose this session over Gergely Orosz's competing talk when they weren't sure anyone would show up. The panel gathers three practitioners with diverse backgrounds in product engineering:
- **Michelle Lim**, co-founder of Flint (an autonomous website platform that builds customer sites overnight) and former founding engineer at Warp. Having worn every startup hat from marketing to product, she recently published a viral Hacker News post arguing that the industry should stop relying on “front end” and “back end” labels to describe engineering preferences.
- **Drew Hoskins**, author of *The Product-Minded Engineer*, who made the rare leap from staff engineer at Stripe to staff product manager at Temporal out of a passion for user-focused engineering.
- **Tuomas Artman**, co-founder and CTO of Linear, the popular issue tracker. Linear is widely known for hiring almost exclusively product engineers and famously operating without any product managers until scaling past 30 employees.
MA outlines the format: roughly 30 minutes of moderated panel conversation followed by 15 minutes of audience Q&A.
---
[02:21](https://www.youtube.com/watch?v=0Cv5763UX70&t=141s) Defining the Product Engineer
MA kicks off the discussion by asking how the panel defines a product engineer and what distinguishes their day-to-day work from non-product engineering roles. Tuomas Artman offers a baseline definition, describing the role as a full-stack engineer who does not merely execute on a handed-down specification, but actually figures out what to build by talking directly to users. As Tuomas Artman puts it: “To me a product engineer is just an engineer with some PM sprinkled on top of it.”
Drew Hoskins expands on this by emphasizing curiosity about purpose over pure implementation details: “A product minded engineer or a product engineer cares at least as much about what and why as they care about how.” He points out that you can spot the difference immediately when asking someone about their career: non-product engineers immediately list technologies and libraries rather than what was actually built for users. Drew also clarifies that product engineering is not limited to user-facing applications. In his view, software constructs are products in miniature:
```mermaid
flowchart TD
accTitle: Interface as a Product
accDescr: Diagram showing how code interfaces function as products connecting to users.
subgraph CodeUnit ["Code as Product"]
F["Function / Class / Module"]
I["Interface / API"]
F --> I
end
subgraph ProductNeeds ["Product Requirements"]
U["Must be understood"]
S["Must be used safely"]
D["Must be discovered"]
end
subgraph Audience ["Users"]
Dev["Developers / Infrastructure Users"]
end
I --> U
I --> S
I --> D
U --> Dev
S --> Dev
D --> Dev
```
Because functions, classes, and modules expose interfaces that require discovery, understanding, and safe usage, someone working deep within internal infrastructure can still operate as a product engineer.
Michelle Lim sharpens the distinction between motivation types: product-minded engineers are driven by user impact and problem-solving, whereas code-minded engineers derive satisfaction from system complexity, elegance, and libraries. While acknowledging that both archetypes are talented, she notes that startups benefit disproportionately from product-minded engineers because small teams cannot support specialized handoffs.
---
[05:24](https://www.youtube.com/watch?v=0Cv5763UX70&t=324s) How Engineers Discover Their Product Mindset
When MA asks whether being product-minded is an innate trait or a learned skill, the panelists reflect on their own career trajectories, demonstrating that it is often discovered through friction with purely code-centric work.
Drew Hoskins admits that coming out of college, he was strictly code-minded, wanting to work exclusively on algorithms and data structures. He joined a compiler team at Microsoft, spending his days reading assembly diffs and implementing back-end compiler optimizations. The turning point arrived when his team built a meta-framework for compiler creation that treated compiler construction like an assembly language. Dismayed by its terrible usability, Drew observed how the C# community was intentionally designing APIs around ergonomics, standardizing human-readable naming conventions, and actively competing with Java on usability. That contrast sparked his realization that developers are human users who deserve well-crafted developer products.
Michelle Lim experienced an early-career crisis while trying to find her niche through internships:
- At **Slack**, she held a front-end engineering internship where she was handed Figma files solely to implement, leaving her feeling detached from deeper computer science problem-solving.
- At **Robinhood**, she tried back-end engineering, migrating PrestoSQL queries while staring exclusively at database rows, SQL, and latency metrics without ever encountering a user.
Feeling unfulfilled by both, Michelle briefly considered pivoting into product management so she could talk to users. She realized the fundamental flaw was how the industry bifurcated jobs: “The industry had been using front end and back end engineering and it ended up putting people in the wrong the wrong professions.” When she joined Warp in 2020 as its first engineer to modernize the terminal, she had the autonomy to identify CLI problems, implement solutions end-to-end, and watch developers use them, solidifying her identity as a product engineer.
Tuomas Artman concludes by sharing that his product orientation began nearly 30 years ago during the pre-internet era, building interactive CD-ROM multimedia presentations and Flash campaign animations where visualization, UI, and compelling presentation were the entire purpose of the software.
[09:45](https://www.youtube.com/watch?v=0Cv5763UX70&t=585s) Implementation Quality and Linear's Strategy
Tuomas Artman explains how he approaches his technical work, acknowledging that while he genuinely enjoys tackling complex technical problems, the complexity itself is never the point. Instead, technical depth serves as a tool to create an exceptional user experience. To illustrate, he shares an example from his own work at Linear: “So, you know, for example, you know, at Linear I wrote the the sync engine for the fourth time. And I didn't do it because like I I wanted to do sync, but I did it because I wanted the user to have a great experience.” He categorizes himself as an engineer leaned more toward implementation quality—fiddling with user interfaces and experiences—rather than being strictly focused on the customer-facing business side.
```mermaid
flowchart LR
accTitle: Two Dimensions of Product Engineering Quality
accDescr: Diagram contrasting conceptual quality and implementation quality.
subgraph Quality["Product Engineering Taste"]
direction TB
CQ["Conceptual Quality<br/>(What to build & how to solve the problem best)"]
IQ["Implementation Quality<br/>(Crafting a 10x better UX around that solution)"]
end
Market["Crowded Incumbent Market<br/>(Project Management)"] --> Quality
Quality --> Outcome["Linear: 10x Better Experience for ICs"]
```
The panel turns to the concept of "taste," particularly in an AI-dominated landscape where engineers must prompt coding assistants with subjective criteria. Artman explains why taste and quality were existential requirements when starting Linear. They entered an overcrowded project management market dominated by well-entrenched incumbents, forcing them to find a clear wedge to win. Their ultimate strategy was distilled into a single word: quality. Rather than attempting to build something incrementally better, their objective was to build something 10x better than any incumbent. They focused specifically on individual contributors (ICs), having observed that ICs were broadly dissatisfied with existing tools. Artman breaks quality down into two distinct pillars:
- **Conceptual quality**: Figuring out what should be built and identifying the best way to solve a given problem.
- **Implementation quality**: Deciding how to execute and polish the user interface and overall experience once the problem has been defined.
[12:26](https://www.youtube.com/watch?v=0Cv5763UX70&t=746s) Interviewing for Taste: Work Trials and First-Principles Simulation
When asked how Linear actually evaluates taste during hiring, Artman describes their intensive, week-long interview process. Linear brings candidates in and pays them for a full week of hands-on collaboration. The goal is for the candidate to build and ship an actual greenfield project. In Linear's earlier days, candidates routinely pushed a completed feature to production by the end of that single week, serving as immediate proof of their initiative and product taste. While the growing complexity of Linear's codebase makes shipping to production within a week less frequent today, it remains a pillar of their evaluation.
Drew Hoskins argues against viewing taste as an inborn, mystical trait: “I it sounds like this mystical thing that like some people have and other people don't have. And so that's that's to me something that I would want to debunk. That I think it can be learned and it can it's a skill. It's like a craft.” He breaks the craft down into "shoe-shifting"—the discipline of selectively forgetting what you know as an engineer to view the product entirely through the user's eyes:
```mermaid
flowchart TD
accTitle: User Simulation Craft Loop
accDescr: The cognitive cycle of simulating a user journey from discovery to safe usage.
A["Step into User Shoes<br/>(Selectively forget technical implementation)"] --> B["Simulate Interactions<br/>(Think several moves ahead like chess)"]
B --> C["Map Key Milestones<br/>(Discovery, understanding, and safe usage)"]
C --> D["Adapt to Novel Context<br/>(Solve from first principles, avoid copy-pasting patterns)"]
D --> A
```
Hoskins compares user simulation to playing chess a few moves ahead to predict confusion, points of friction, and discovery moments. In technical design interviews, Hoskins assesses taste by embedding user-centric constraints into system architecture problems. Candidates must demonstrate that their technical choices stem from an understanding of user needs and motivations. A major anti-pattern he flags is relying on canned, off-the-shelf solutions:
- **Staff-level behavior**: Candidates instinctively uncover the user context and solve from first principles without prompting.
- **Senior-level behavior**: Candidates may need light coaching or prompting, but quickly orient their design decisions around user motivations.
- **The anti-pattern**: Falling back on memorized patterns from previous companies rather than tailoring the design to the specific, unique requirements of the problem at hand.
[15:38](https://www.youtube.com/watch?v=0Cv5763UX70&t=938s) Exposure, Magic, and Company Rituals for Taste
Michelle Lim emphasizes that taste is the primary differentiator in crowded markets, especially within AI-driven software development. At Flint, where the team builds autonomous websites for enterprise-serving clients like Cognition, visual and functional standards are paramount. Code-generation tools often default to generic, low-effort aesthetics—such as ubiquitous purple gradients and rounded corners—which look unprofessional to enterprise buyers. If engineers lack taste, their autonomous agents and output mirror that mediocrity, eroding customer trust.
Lim outlines two essential inputs for cultivating taste on engineering teams:
1. **Broad, cross-domain exposure**: Experiencing great design beyond software. Lim encourages engineers to analyze physical product packaging (like opening a MacBook), critique high-end restaurant service, or watch films weekly to sharpen their critical eye for nuance.
2. **Direct customer intimacy**: Talking directly to users to understand what creates genuine love and satisfaction.
Addressing engineering managers on how to foster these instincts, Lim highlights two operational practices:
- **Hiring taste leaders who set high standards**: Flint hired Netflix's former head of design, who routinely challenges incrementalism. When engineers propose a safe, standard feature seen in competing products, she pushes back: “No. How do we make this magic? Can we push the boundary? Do we really want to have this same feature that all of the other tools have?”
- **Dedicated exploration spaces**: Flint maintains an internal Slack channel called `#agentic-development`, explicitly dedicated to analyzing AI workflows, new market tools, and emerging techniques. Management treats spending an hour or two dissecting other products as high-leverage work rather than wasted time.
[19:14](https://www.youtube.com/watch?v=0Cv5763UX70&t=1154s) Developer Flows and User Stories as API Review Tools
Drew Hoskins reflects on how teams can foster user-centric thinking even without traditional managerial authority. While he notes he has never been a manager and likely never will be, he spent years serving on the centralized API review team at Stripe. Rather than merely enforcing technical consistency across disparate orgs, Hoskins introduced a dedicated "developer flows" section into their review template. Engineers submitting API proposals were forced to map out a concrete step-by-step journey: explaining how a consumer gets their inputs, why they invoke a given endpoint, and how the interaction narrative unfolds. Because many engineers initially struggle to write developer flows, the review team worked alongside them to construct increasingly detailed, "bushier" user stories.
This requirement served two critical purposes. First, it forced engineers to step into the user's shoes and empathize with their end-to-end journey. Frequently, just drafting the narrative revealed hidden interface flaws to the author before reviewers even saw the code: “in a lot of times what happened is actually as they wrote the stories, they figured out the the the problems themselves, and then they didn't have to talk to us.” Second, the narrative functioned as an efficient communication bridge, allowing reviewers to rapidly understand another team’s domain. Hoskins points to similar practices elsewhere at Stripe, citing Principal Engineer Michelle Bu, who developed a "use case compendium" representing the North Star scenarios against which systems were continuously measured.
- The developer flows template prompted engineers to outline input origins, call motivations, and step-by-step developer progressions.
- The exercise doubled as self-debugging: writing the narrative regularly exposed design gaps before review meetings ever took place.
- Michelle Bu established an org-wide use case compendium at Stripe to anchor product success directly to real user journeys.
[21:37](https://www.youtube.com/watch?v=0Cv5763UX70&t=1297s) Linear's "Quality Wednesdays": Building Taste by Chasing Micro-Defects
Tuomas Artman explains how Linear cultivates meticulous product taste across its engineering team through a weekly ritual known as "Quality Wednesdays." The practice originated three years prior out of personal frustration with UI micro-interactions. Linear's design specifications strictly dictate that hovering over an element triggers an instant highlight, while hovering out requires an exact 150-millisecond fade-out. Artman found himself fixing broken fade-outs for the tenth time and realized that if engineers do not know what visual nuances to look for, they simply cannot see their own mistakes.
```mermaid
flowchart TD
accTitle: Linear Quality Wednesday Workflow
accDescr: Cycle showing how engineers find, fix, and present micro-defects weekly.
subgraph DefectCycle["Weekly Defect Ritual"]
A["Engineer inspects app during regular use"] --> B["Identify non-breaking defect\n(misalignment, broken highlight)"]
B --> C["Implement micro-fix\n(kept separate from blocker bugs)"]
C --> D["Present and celebrate fix\nto entire team on Wednesday"]
D --> A
end
```
To train the team's visual perception, Artman conducted an exercise at a company offsite, isolating a small portion of the application and asking the team to log every minor flaw they could spot. Expecting around four defects, he was astonished when the team uncovered twenty. That revelation inspired "Quality Wednesdays": every single week, each engineer is expected to hunt down, repair, and demo a non-critical defect—such as an improper alignment or a missing transition—separate from standard bugs that get resolved immediately. Over two years, Linear's team resolved approximately 2,500 defects this way. Beyond the sheer volume of fixes, the ritual fundamentally reframes how engineers interact with software:
> “It sets your mind up into sort of this this, you know, bug finding mode or defect finding mode, um and that helps you become a a better product engineer.”
- Defect hunting operates separately from urgent bug triage; bugs are patched immediately, while defects target polish and visual fidelity.
- Demonstrating fixes company-wide creates shared awareness, teaching the entire team to recognize design flaws they previously overlooked.
- Over 2,500 subtle product defects were uncovered and resolved in the first two years of the weekly program.
[24:00](https://www.youtube.com/watch?v=0Cv5763UX70&t=1440s) AI-Native Workflows: Multi-Agent Parallelism and Real-Time Customer Triage
Turning to modern workflows in 2026, Michelle Lim contrasts the older synchronous rotations with the current AI-native environment. At Warp, polish and minor bugs were historically handled by a designated "product quality rotation," where one engineer tackled tickets sequentially for an entire week. Today at Flint, this bottleneck has vanished. Instead of waiting for a weekly rotation, each engineer commonly operates around four Claude Code background agents concurrently alongside their primary feature work. Daily standups now reflect this multi-threaded reality, with engineers declaring their primary objective alongside several background AI workstreams that silently crush polish issues and minor fixes all day.
Customer feedback loops have seen an identical acceleration. Lim conducts sales calls from early morning until evening, using call recording and summary software to automatically stream transcripts, notes, and spotted bugs straight into a dedicated Slack channel. Engineers monitoring the feed promptly dispatch Claude to fix identified bugs on the spot:
> “It's really incredible because sometimes I would see a bug happen at 8:00 a.m. and then by 11:00 a.m. uh it's already fixed.”
For architectural or deeper platform problems that exceed what an agent can reliably patch on the fly, engineers rely on the Linear Slack integration to log formal tickets and prioritize them for the upcoming week.
- Flint engineers routinely juggle their primary project while supervising roughly four concurrent Claude Code agents in the background.
- Sales call recordings and auto-generated defect summaries pipe directly into Slack to drive immediate agent-based remediation.
- Substantial architectural issues that AI cannot resolve instantly are escalated into Linear tickets for deliberate sprint scheduling.
[26:19](https://www.youtube.com/watch?v=0Cv5763UX70&t=1579s) Short Feedback Loops and Denoising Customer Signal with AI
Drew Hoskins emphasizes that collapsing the distance between problem discovery and production deployment changes engineering psychology: “If you know that it's going to take you 6 months to fix any bug that a user is going to report, then why would you bother even talking to users?” The instant gratification of real-time remediation makes interacting with customers intrinsically rewarding rather than exhausting. Furthermore, AI tooling is moving upstream into strategic product capabilities. At Temporal, Hoskins' team relies on Claude-driven product management skills to run competitive analysis and surface targeted customer signals. When contemplating a new feature, engineers query the system to retrieve exact user quotes, cross-referencing Gong calls, GitHub issues, support interactions, and customer Slack threads to instantly assemble a candidate user list.
This denoising capability fundamentally changes how organizations scale user engagement. Hoskins cites his car manufacturer, which launched a wide-open email inbox inviting drivers to submit raw complaints about their vehicles, utilizing an AI system behind the scenes to filter and categorize the incoming volume. By filtering out overwhelming chatter, AI prevents product engineers from becoming burnt out by user interaction, encouraging them to seek out customer contact instead of pulling back in horror.
Building on these workflow transformations, Tuomas Artman notes that AI's greatest gift to product engineering is the near-zero marginal cost of prototyping. Where engineers previously hesitated to tackle complex or unfamiliar interface patterns due to the heavy upfront time investment, they can now spin up rough, functional experiments effortlessly to test a product hunch before writing permanent code.
[28:41](https://www.youtube.com/watch?v=0Cv5763UX70&t=1721s) Designers and PMs Shipping Code with AI
With AI coding tools lowering implementation barriers, the traditional friction of trying out speculative ideas has disappeared. Previously, if an engineer felt an idea might work but would take a week to build, they would never try it—they would simply ask design to alter or reconfigure it. Now, engineers and designers alike can test concepts directly in production or via preview builds. Tuomas Artman notes that at Linear, designers spin up Claude to implement their own designs and test them hands-on before pushing to production: “We do have multiple designers who, you know, take their designs to the next level where they're like, 'Oh, I want to try it out on the product.' And they just spin up Claude and, you know, have it implement the designs that they do and then ship it—not ship it in production, but as a preview build so that they can actually use their designs.”
Michelle Lim shares a similar shift at Flint. Her lead designer—formerly the head of design at Netflix with a 12-year career and zero prior coding experience—used to spot misaligned borders, off-palette greys, buried features, or broken information architecture and file engineering tickets that sat in backlogs. Today, she writes five to six pull requests each week herself. The moderator echoes this cultural shift, recalling that around Q3 of the prior year, their head of engineering called in a panic warning that designers and product managers were shipping code directly to the repository. That alarm quickly shifted to celebration once leadership realized the product's UX was compounding in quality every single week.
```mermaid
flowchart LR
accTitle: Evolution of Design Iteration
accDescr: Comparison between the traditional design handoff workflow and the AI-assisted rapid prototyping workflow.
subgraph Traditional["Traditional Workflow"]
T1["Designer spots UI flaw"] --> T2["Files ticket"]
T2 --> T3["Eng backlog"]
T3 --> T4["Slow or deprioritized fix"]
end
[30:27](https://www.youtube.com/watch?v=0Cv5763UX70&t=1827s) Parting Wisdom: Direct Customer Contact over Summaries
Opening the final lightning round of advice before audience Q&A, the panel was asked for their core guidance on becoming a stronger product engineer or cultivating product instincts across a team. Michelle Lim highlights the danger of over-relying on automated tooling when trying to build user empathy. While AI summarizers and note-takers are helpful efficiency tools, they cannot replace the visceral impact of interacting with another human being. To institutionalize this instinct, she enforces direct customer touchpoints across her entire engineering team:
> “There’s just something about like a human meeting another human that really develops empathy in a way that reading a summary of calls would never do. So, it is important to me to bring my engineers to customer site visits, and then I also make sure that every engineer attends at least one sales call with me every week.”
[31:13](https://www.youtube.com/watch?v=0Cv5763UX70&t=1873s) Running the Metric Gradient from Vanity to Deep Value
Drew Hoskins advises tech leads and managers to steer teams away from superficial tracking and instead “run the gradient from vanity metrics to adoption metrics to metrics that really capture the value that users are getting out of it, and then goal your engineers on those metrics.” Using a social network as an illustration, he steps through the trap of progressively flawed metrics:
```mermaid
flowchart TD
accTitle: The Product Metric Gradient
accDescr: A hierarchy of metrics moving from easily measured vanity metrics up to deep counterfactual value metrics.
M1["Vanity Metrics<br/>(Total sign-ups — e.g. MySpace)"] --> M2["Adoption & Activity<br/>(MAU / DAU — indicates retention or addiction)"]
M2 --> M3["Time Spent<br/>(Can simply indicate addictive AI slop)"]
M3 --> M4["Meaningful Interactions<br/>(Posting, commenting, connecting with friends)"]
M4 --> M5["Deep Value & Counterfactuals<br/>('Would your company exist without this product?')"]
```
- **All-time sign-ups:** A pure vanity metric where dead platforms like MySpace still score impressively high.
- **Monthly Active Users (MAU):** Signals retention, but obscures whether users are gaining value or merely trapped in addictive loops.
- **Time spent:** Highly deceptive, as heavy engagement can simply represent users mindlessly consuming low-quality AI slop.
- **Meaningful interactions:** Measurable actions such as deliberate choices, comments, likes, and genuine connections with friends.
- **Counterfactual value questions:** In-depth surveys that assess indispensable value, such as asking users how much they would need to be paid to walk away, or Stripe's signature inquiry to startups: *“Would your company exist without Stripe?”*
Hoskins acknowledges the structural difficulty of this approach: as you travel further toward true value, metrics take much longer to track and become harder to quantify cleanly. Leaders must be obsessive about unearthing these genuine signals and directly tying them to performance reviews, especially for senior engineers.
[32:27](https://www.youtube.com/watch?v=0Cv5763UX70&t=1947s) Giving Engineers Time to Protect Quality
Tuomas Artman directs his parting advice toward engineering managers, urging them to give engineers dedicated breathing room to craft high-quality software rather than chaining them purely to short-term data experiments. Because craft and product stability cannot be validated via rapid A/B testing, neglecting them causes cumulative degradation: “If you don't think about quality, your product will degrade over time. So a year later, maybe you will have a lower-quality product and you lose one a month to somebody else if you don't do that.” Engineers naturally yearn to take pride in their craft and ship work they respect, but management constraints frequently box them out of doing so.
To illustrate this, Artman recounts a personal experience with Uber, where he previously worked as a mobile engineer. After opening the consumer app following a prolonged hiatus, he was shocked to uncover 10 distinct bugs within 10 seconds. Frustrated, he posted a public tweet asking what had happened to the company’s pride in craft:
> “I tweeted out saying like, 'What happened? Why—we used to care about these things.' And that, you know, created a stir at Uber, and they had a Code Yellow and they started fixing bugs. And engineers started tweeting back, DMing me back saying, 'Thank you. Thank you for raising this from the outside and having our managers give us the time to fix these bugs.'”
## Notable quotes
> [02:21](https://www.youtube.com/watch?v=0Cv5763UX70&t=141s) A product minded engineer or a product engineer cares at least as much about what and why as they care about how. — Drew Hoskins
> [32:27](https://www.youtube.com/watch?v=0Cv5763UX70&t=1947s) If you don't think about quality, your product will degrade over time. — Tuomas Artman
> [02:21](https://www.youtube.com/watch?v=0Cv5763UX70&t=141s) To me a product engineer is just an engineer with some PM sprinkled on top of it. — Tuomas Artman
> [30:27](https://www.youtube.com/watch?v=0Cv5763UX70&t=1827s) There’s just something about like a human meeting another human that really develops empathy in a way that reading a summary of calls would never do. — Michelle Lim
> [26:19](https://www.youtube.com/watch?v=0Cv5763UX70&t=1579s) If you know that it's going to take you 6 months to fix any bug that a user is going to report, then why would you bother even talking to users? — Drew Hoskins
## Mentioned
Claude, Claude Code, Cognition, Drew Hoskins, Figma, Flint, Gergely Orosz, GitHub, Gong, Linear, Michelle Bu, Michelle Lim, Microsoft, MySpace, Netflix, Robinhood, Slack, Statsig, Stripe, Temporal, The Pragmatic Engineer, The Product-Minded Engineer, Tuomas Artman, Uber, Warp
## Video description
With Tuomas Artman (cofounder, Linear), Michelle Lim (cofounder, Flint), and Drew Hoskins (author, The Product-Minded Engineer). At The Pragmatic Summit: www.pragmaticsummit.com
Watch the session with Q&A also included: https://newsletter.pragmaticengineer.com/p/the-pragmatic-summit-recordings
0:00 Intro
2:15 What is a product engineer?
6:00 Product-minded vs code-minded engineering
10:05 Career paths into product engineering
13:30 Hiring for quality, taste, and customer orientation
18:40 Building product engineering muscle on teams
23:20 Management practices for customer exposure
27:50 AI-native workflows and product quality rituals
32:05 PM role boundaries
37:30 Speed vs quality tradeoffs in AI-heavy development
Product-minded engineering centers on user empathy, conceptual craft, and problem-solving rather than technical implementation details alone. In an AI-native environment, panelists argue that automated tools lower prototyping costs and accelerate triage, making human taste and direct customer contact the ultimate competitive differentiators.
Defining the Product-Minded Engineer (2:21)
Panelists define a product-minded engineer as someone who cares as much about the "what" and "why" of software as the "how," rather than simply implementing handed-down technical specifications. Drew Hoskins notes that software constructs such as APIs and internal modules function as products requiring discovery and safe usage, meaning infrastructure engineers can also be product-minded. Michelle Lim distinguishes this archetype from code-minded engineers who prioritize architectural complexity and libraries, arguing that early-stage startups benefit disproportionately from product engineers because small teams cannot absorb the overhead of specialized handoffs.
Taste and Quality as Strategic Wedges (9:45)
Tuomas Artman explains that Linear used quality as its primary strategy to disrupt a crowded project management market, targeting individual contributors dissatisfied with existing tools. He divides quality into conceptual quality (identifying what to build) and implementation quality (refining the interface and interaction). To assess taste during hiring, Linear brings candidates in for paid, week-long work trials to build greenfield projects. Hoskins rejects the idea that taste is innate, describing it as a craft of "shoe-shifting"—the disciplined practice of mentally shedding technical implementation knowledge to predict user confusion.
Rituals and Tools for User Empathy (19:14)
Organizations build intuition through structured team habits. At Linear, a weekly ritual called "Quality Wednesdays" tasks engineers with hunting and resolving micro-defects—such as an improper alignment or a missing 150-millisecond hover fade-out—resulting in 2,500 subtle fixes over two years. At Stripe, Hoskins introduced a mandatory "developer flows" section into API review templates, forcing authors to narrative-map end-to-end user journeys. This drafting process frequently exposed interface flaws to engineers before formal reviews occurred.
AI-Native Workflows and Compressed Feedback Loops (24:00)
AI coding assistants are altering daily development patterns by eliminating synchronous triage bottlenecks. At Flint, engineers monitor customer sales call transcripts and triage bugs with up to four background Claude Code agents running concurrently alongside their core tasks, allowing defects spotted in the morning to be deployed by midday. Furthermore, reduced implementation barriers enable non-engineers to prototype directly: Linear designers implement preview builds using Claude, while Flint's design lead authored five to six pull requests weekly despite having no prior coding background.
Direct Human Empathy Over Automated Proxies (30:27)
Despite the rise of AI note-takers and summarizers, panelists warn against using automation as a substitute for direct customer interaction. Lim mandates that her engineers attend customer site visits and at least one live sales call weekly, maintaining that human contact generates empathy that summarized text cannot replicate. Hoskins similarly urges leaders to evaluate engineers against deep value metrics—such as asking whether a customer's business could exist without the product—rather than superficial engagement or vanity sign-up metrics.
The panelists conclude that while AI tools compress iteration cycles and enable cross-functional code generation, engineering managers must actively protect time for unquantifiable polish. Without deliberate room for craft, products suffer cumulative degradation that rapid data experiments and short-term A/B testing fail to catch.
Source quotes
[2:21] Drew Hoskins: A product minded engineer or a product engineer cares at least as much about what and why as they care about how.
[32:27] Tuomas Artman: If you don't think about quality, your product will degrade over time.
[2:21] Tuomas Artman: To me a product engineer is just an engineer with some PM sprinkled on top of it.
[30:27] Michelle Lim: There’s just something about like a human meeting another human that really develops empathy in a way that reading a summary of calls would never do.
[26:19] Drew Hoskins: If you know that it's going to take you 6 months to fix any bug that a user is going to report, then why would you bother even talking to users?
Original transcript
[0:04] Well, great to see everyone. Thank you
[0:06] for choosing us over the Gerga session,
[0:09] which that's an honor.
[0:11] We were already knowing when show up.
[0:12] Um, so my name's MA. I lead uh the
[0:15] product and design teams at Statsig and
[0:17] we have an awesome panel today to talk a
[0:19] little bit about product engineers,
[0:22] how that looks, um how you can kind of
[0:24] build that muscle, how you can coach
[0:26] that in your teams, and then some cool
[0:28] stories about how that actually
[0:29] manifests at different companies. So,
[0:32] joining me today are my amazing
[0:33] panelists. So, we'll start here.
[0:35] Michelle is the co-founder of Flint, an
[0:38] autonomous website platform. She was
[0:39] just telling us about her customers'
[0:41] websites that just get built overnight
[0:43] by themselves.
[0:44] Very cool stuff. Um prior to Flint, she
[0:46] was the founding engineer at warp.dev
[0:49] and across all these roles in startups,
[0:52] as many of you who are in startups know,
[0:53] when you're the early employee at a
[0:55] startup, you end up being the everything
[0:58] engineer, whether that's marketing or
[1:00] product or, you know, XYZ. And so,
[1:02] Michelle,
[1:03] um
[1:04] as, you know, an early employee kind of
[1:06] built this product engineering muscle
[1:08] and in fact wrote a recent post called
[1:10] stop using front end and back end to
[1:12] describe the engineering you like that
[1:13] apparently went viral on Hacker News.
[1:15] So, check that out.
[1:17] Next, we have Drew, who was such a
[1:19] passionate product engineer that he
[1:20] actually formally transitioned from
[1:22] engineering to product. Um and so, he
[1:25] was a staff engineer at Stripe, jumped
[1:27] to being a staff PM at Temporal. That is
[1:30] a crazy transition, so I'm very curious
[1:31] to hear more about that, but also in the
[1:33] process, he actually wrote the book on
[1:35] the topic we're going to talk about
[1:36] today called The Product Minded
[1:38] Engineer.
[1:40] And then last but not least, we have
[1:41] Thomas, who is co-founder and CTO of
[1:44] Linear, the leading issue tracker and
[1:46] management tool uh for teams. I use
[1:48] Linear. Probably many of our teams are
[1:50] built on Linear. Amazing product.
[1:53] Um and, you You Linear is famous for
[1:56] hiring pretty much exclusively product
[1:58] engineers and famously did not have any
[2:01] PMs until they grew to over 30 folks.
[2:04] So, curious to hear about that culture
[2:06] and how you kind of made that decision
[2:07] early on.
[2:09] Um okay, so let's hop in. We have about
[2:12] 30 minutes of moderated discussion and
[2:14] then we will do 15 minutes of audience
[2:17] Q&A. So, if you do have questions, queue
[2:18] those up for the end.
[2:21] So, we're talking about product
[2:22] engineers today. I think the first
[2:24] question we have to ask is actually, you
[2:27] know,
[2:28] what is a product engineer? How do you
[2:29] guys define that and what does a product
[2:32] engineer do day-to-day that might look
[2:34] different from a non-product engineer?
[2:39] I can start with a simple explanation
[2:41] you can you can build on on top of that.
[2:43] Um to me a product engineer is just an
[2:44] engineer with some PMs sprinkled on top
[2:47] of it.
[2:48] Um a engineer who can sort of not only,
[2:51] you know,
[2:52] uh take a vision and then then implement
[2:54] it but also define that vision. Um talk
[2:57] to customers, figure out what customers
[2:59] need um and then go ahead and build that
[3:01] thing. So, you know, a full stack
[3:03] engineer that is even more full stack as
[3:05] in, you know, being able to define, you
[3:07] know, the the thing that should be
[3:08] built.
[3:11] Yeah, I would just add uh
[3:13] that a product minded engineer
[3:15] or a product engineer cares at least as
[3:17] much about what and why as they care
[3:19] about how.
[3:21] And you can kind of detect it when
[3:24] um you're talking to somebody like if I
[3:26] was talking to somebody, "Hey, what have
[3:27] you done in your career?" and they they
[3:29] started talking about not what they
[3:31] built but the technologies that they had
[3:33] built it with.
[3:34] And so that's a not a product engineer,
[3:36] right? And so in and so, you know, one
[3:39] of the behaviors is just that focus on
[3:40] the user and
[3:42] um
[3:44] and then I think I would just clarify
[3:45] that for me and
[3:47] the product the concept of a product
[3:49] like a function is a product, a class is
[3:51] a product, a module is a product. Like
[3:53] everything Anything that has an
[3:55] interface that human I guess humans
[3:56] don't read functions anymore because of
[3:58] AI, but like imagine a year ago,
[4:01] um you might look at a function that's a
[4:02] product, right? Because it's got an
[4:03] interface, it's got to be understood,
[4:05] it's got to be used safely, um it's got
[4:08] to be discovered. So, all these things
[4:09] of like connecting that function with
[4:11] the world is essentially a product in
[4:14] miniature. And so, what that means is
[4:15] like
[4:16] you don't have to be working on a
[4:18] product a user-facing product to be a
[4:20] product engineer. You can be uh deep in
[4:22] the infrastructure, but you still got
[4:23] users and you still got um
[4:26] yeah.
[4:29] Yeah, so a product-minded engineer is as
[4:32] opposed to a code-minded engineer in
[4:34] terms of their motivation. So, a
[4:37] product-minded engineer is someone who's
[4:39] motivated by the user impact. Um like
[4:41] Drew said, when they think of something
[4:43] that they're building, they're thinking
[4:44] about um the user, their problems, uh
[4:47] how else problems solved. Whereas, a
[4:49] code-minded engineer tends to be more
[4:51] focused on libraries, um the complexity,
[4:55] the elegance of the systems that they
[4:57] get to build. And both types of
[4:59] engineers um
[5:01] uh talented in their own ways.
[5:03] Um
[5:04] I find that in a startup, it's a lot
[5:06] more beneficial to get more uh
[5:08] product-minded engineers because there
[5:10] are just fewer roles that you can hire,
[5:12] fewer people in a team. And so, the more
[5:14] each person can do everything full stack
[5:17] from defining the problem to solving it
[5:19] and then testing it out in the wild,
[5:20] that is uh the better for a startup.
[5:24] So, maybe it's making a jump, but I
[5:25] assume that all three of you are
[5:27] product-minded engineers. So, I'm
[5:29] curious, how did you get your start in
[5:32] this role? Was it just innate? Do you
[5:33] think this is truly something that you
[5:35] just either are or aren't? It's very
[5:36] binary. Or do you think this is a skill
[5:39] set that can kind of be taught and
[5:40] coached over time?
[5:42] I'll start here. I was uh
[5:44] when I came out of college, I was like
[5:46] hardcore and I loved I wanted to do
[5:49] algorithms, you know, and data
[5:52] structures because you know, that's what
[5:53] I knew as an undergrad at um
[5:56] and I went and I joined a compiler team
[5:58] at Microsoft and so I was like, you
[6:00] know, doing like reading assembly diffs
[6:02] and doing back-end optimizations and
[6:04] stuff.
[6:05] And it was not producty
[6:07] even a little bit, right? And um
[6:11] the thing that switched me was my
[6:13] my team started building a framework for
[6:15] building compilers. So like, you know,
[6:17] it had abstractions like functions and
[6:19] instructions and operands and types and
[6:21] symbols and all these things and you
[6:22] could you could create compilers with
[6:24] it. And it had a terrible API and the
[6:26] the chief architect's vision for this
[6:29] um
[6:30] this framework was the assembly language
[6:32] for building compilers.
[6:35] And I just thought, who wants to program
[6:36] in assembly language, you know, like
[6:38] nobody. And and then I started noticing
[6:41] the C# community was like really into
[6:44] getting into usability and like how how
[6:46] do we build functional APIs that
[6:47] developers can actually understand? They
[6:49] started having design standards and
[6:51] naming standards and things to just like
[6:53] don't abbreviate, you know, simple
[6:54] things. And then um we're putting a lot
[6:56] of thought into their APIs cuz they were
[6:58] trying to compete with Java and so they
[6:59] had to do something that was easier to
[7:01] use than Java.
[7:02] And that was when I was like, wow, you
[7:04] know, developers are people too. They're
[7:05] you know, we're building products for
[7:06] developers and that's that was my pill
[7:08] was like just getting into API design.
[7:11] And then that just sort of blossomed
[7:12] over time into a more general interest
[7:14] in in product.
[7:17] In college I had really big crisis of
[7:20] figuring out what I wanted to do. So I
[7:22] did an internship um at Slack where I
[7:25] was a front-end engineering internship,
[7:27] but all I was given uh Figma files to
[7:30] implement. And so I didn't feel like I
[7:32] was using my computer science degree to
[7:34] use data structures or algorithms at
[7:36] all.
[7:37] And then I ended up working um more of a
[7:40] back-end engineering uh job at uh
[7:43] Robinhood and I didn't see any users at
[7:45] all. I was migrating Presto QL
[7:49] and all I saw was sequel and data rows
[7:52] and latency.
[7:53] So that made me think like oh like if I
[7:56] didn't enjoy front end engineering or
[7:59] back end engineering, maybe I should
[8:00] just become a PM. Because I'm sure like
[8:03] PM gets to talk to the users and they
[8:04] get to like solve problems and see the
[8:06] benefit of the work that they're doing.
[8:09] And then I realized that actually
[8:11] um
[8:12] it's because I've been using like the
[8:14] industry had been using front end and
[8:16] back end engineering
[8:18] and it ended up putting people in
[8:21] the wrong
[8:23] the wrong professions.
[8:25] Instead, you should be thinking about
[8:27] product engineering versus code
[8:29] engineering or infra engineering.
[8:31] And as soon as I found that distinction,
[8:34] I realized that as a product engineer, I
[8:37] would be able to like understand the
[8:38] customer problem and then solve it no
[8:40] matter if it's a front end or back end.
[8:43] I ended up joining Warp which at the
[8:45] time was trying to build a modern
[8:47] version of the terminal.
[8:49] I met the founder, he showed me a slide
[8:50] deck. I thought it was really cool to
[8:52] improve the terminal.
[8:53] I joined as his first engineer
[8:56] back in 2020 and I was able to come up
[8:58] with
[9:00] ideas for how I can improve the CLI and
[9:02] then also build it and then test it and
[9:06] then see users use it. And that's when I
[9:08] realized that oh, I'm definitely a
[9:10] product engineer.
[9:11] I was just in the wrong internships.
[9:14] Yeah. I I started my career ages ago
[9:18] like 30 years ago doing CD-ROM
[9:20] multimedia presentations. Um before the
[9:23] internet was a thing and it was all
[9:24] about like visualizations and great UI
[9:27] and you know presenting you know some
[9:29] problem in a in a you know visual
[9:30] manner. Um and then I do that you know a
[9:32] lot of flash and campaigns so animations
[9:34] and and all that stuff that is sort of
[9:36] you know, very
[9:37] you know,
[9:38] very intriguing user interfaces. So,
[9:40] I've always always done that. Then I've
[9:42] done mobile development and
[9:44] infrastructure and literally everything
[9:45] in in between.
[9:47] And I've noticed that like I I I do like
[9:50] very complex technical challenges, but
[9:52] it's not because of the complexity but
[9:54] because I can use it to actually make
[9:56] the the user experience better. So, you
[9:59] know, for example, you know, at Linear I
[10:00] wrote the the sync engine for the fourth
[10:02] time. And I didn't do it because like I
[10:06] I wanted to do sync, but I did it
[10:08] because I wanted the user to have a
[10:10] great experience.
[10:11] So, I'm sort of I I guess more geared
[10:13] towards sort of the implementation
[10:14] quality side of of a
[10:17] of a product engineer and not so much on
[10:19] the customer side, but I I I like to
[10:20] sort of, you know, toy around with user
[10:23] experiences and interfaces.
[10:26] So, let's actually double click on that
[10:28] kind of implementation side of product
[10:30] engineering. How, you know, a big part
[10:32] of this is probably this concept of
[10:34] taste, which is also hotly contested in
[10:36] an AI world where you're kind of having
[10:39] to prompt taste to a coding assistant in
[10:42] some sense.
[10:43] Um,
[10:44] how would you define taste and and how
[10:47] do you think that is like how core is
[10:49] that to being a good product engineer
[10:50] versus something that you,
[10:52] you know, can kind of build that muscle
[10:53] for over time by just talking to
[10:55] customers or kind of being in the weeds
[10:57] on the end to end?
[11:02] I I think it's super important. Like at
[11:03] least, you know,
[11:05] from Linear's side, like when we started
[11:07] Linear,
[11:08] um, we we we came into a space that was
[11:11] fully occupied. Like there's so many
[11:13] incoming solutions for project
[11:14] management. Um, so we had to figure out
[11:16] like what what is our what is our entry
[11:18] into into the space and how how can we
[11:20] win um in the space? Um, and we came up
[11:22] with this, you know, in hindsight it's
[11:24] it's ridiculously simple. Um, it's
[11:26] literally just like our strategy is is
[11:28] one word and that word is quality. Um,
[11:30] we wanted to build a product that it was
[11:32] like, you know, not two times better,
[11:33] but 10 times better. Um, than any
[11:36] incumbent solution. Um, and we started
[11:38] with with, you know, building for uh,
[11:40] for ICs, cuz we we felt that that was
[11:42] sort of the under-served market. Like,
[11:44] we had heard that ICs weren't happy
[11:46] with, you know, any any of the project
[11:47] management solutions out there. Um, so
[11:49] we started working on that and we we we
[11:51] said like, you know, we want to hire
[11:52] people who who have the same sort of
[11:54] taste in quality as we do. And maybe
[11:57] that's two things. Like, there's
[11:58] conceptual quality of like figuring out
[12:01] what what needs to be built, what should
[12:03] be built, how a problem can be can be
[12:05] solved the best. And then there's the
[12:06] implementation quality. Like, once
[12:08] you've defined what you want to build,
[12:10] like, how best can you create an user
[12:12] experience around around that? Um, and
[12:14] that's what we started started hiring
[12:16] for. Like, we wanted to get um, people
[12:18] that had a a similar taste in quality
[12:21] and design uh, that we had um, and have
[12:23] just, you know, have a go at it. Can Can
[12:26] I double click on that? How do you
[12:27] actually interview for taste?
[12:30] Um,
[12:30] we do an interview process that is
[12:33] pretty long. It's a full week. Uh, so we
[12:35] work together. We pay for our um,
[12:37] candidates to come in and actually ship
[12:39] something. Or hopefully ship something.
[12:41] Like, in the early days, they actually
[12:42] would ship something. Like, they would
[12:43] work for a week on a green field project
[12:45] and then by the end of the week we would
[12:47] ship it into production. And that's how
[12:48] we knew, you know, whether they had good
[12:50] taste. Cuz they would have to take the
[12:51] initiative um, in in in building the the
[12:54] functionality and the feature out. Um,
[12:56] and uh, yeah, we we still do that today.
[12:59] Um, the product is a bit more
[13:00] complicated, so people don't ship that
[13:02] often, but it still happens someday.
[13:04] That's really cool.
[13:06] Um, okay, next.
[13:07] Yeah, I I I like um, taking of taste in
[13:11] terms of I it sounds like this mystical
[13:12] thing that like some people have and
[13:14] other people don't have. And so that's
[13:17] that's to me something that I would want
[13:19] to debunk. That I think it can be
[13:22] learned and it can it's a skill. It's
[13:24] like a craft. It's a craft. And the
[13:26] elements of that craft are are being
[13:29] able to shift to shoe shift, to put
[13:32] yourself in your user's shoes, like
[13:33] selectively forget what do you know, and
[13:36] and and and just think about how the
[13:37] user is going to experience your
[13:39] product. And um discover your product,
[13:41] understand your product, and then use
[13:43] your product safely. And being able to
[13:45] simulate those interactions, right? Like
[13:47] actually have almost like playing chess
[13:49] and being able to see a few moves ahead.
[13:51] It's like
[13:52] going through the the user's how they're
[13:55] going to interact with your product,
[13:56] what what they're going to be confused
[13:57] about. And of course, you don't just
[14:00] have that all at once. You have to
[14:01] develop that skill, and that comes from
[14:03] both talking to users, pushing yourself
[14:06] to like,
[14:07] you know,
[14:08] tell bigger stories about the the user
[14:10] experience with your product. And as far
[14:14] as how to interview for
[14:16] for design taste, I ask
[14:20] like I I I I squeeze it into my my like
[14:23] traditional like, you know, design
[14:26] problems that I give. So, I always make
[14:28] want to make sure that there's a user
[14:30] component to whatever they're designing,
[14:33] and the decision the design decisions
[14:34] that they're going to make are going to
[14:35] depend on how they conceptualize what
[14:37] the user's need and what the user's
[14:38] motivations are.
[14:40] And and hopefully they bring it up, or
[14:42] if they don't bring it up, then you
[14:45] know, like at at like at at staff
[14:47] levels, they just kind of can figure it
[14:48] out. And then at senior levels, maybe
[14:50] they need a little prompting to figure
[14:51] it out. Um to to think about the user
[14:54] and then you can help help coach them
[14:56] through that a little bit. And so,
[14:58] um you know, one of the anti-patterns I
[15:01] see is like people who when you're
[15:02] interviewing them, they fall back on
[15:04] existing knowledge, rather than thinking
[15:06] through this new thing they're being
[15:08] given from first principles and
[15:09] understanding like, okay, yes, I've seen
[15:12] something like this before, but this is
[15:13] a little bit unique. I I need to adapt
[15:15] my product to this new circumstance cuz
[15:17] every every product has to be unique
[15:19] because otherwise it's going to fail in
[15:20] the market, right? It has to be And so
[15:23] you want to make sure to give a question
[15:24] that's not just do this thing that
[15:27] that a thousand people have done before,
[15:28] but actually like give it a twist and
[15:30] then make sure that they can adapt their
[15:33] um
[15:34] their like simulation skills to a new a
[15:36] new situation.
[15:38] Yeah, taste is extremely important. Um
[15:40] it is the
[15:42] way you differentiate your product uh in
[15:45] very crowded spaces today.
[15:47] Um
[15:48] like we're building autonomous websites
[15:51] for our customers like Cognition. Um it
[15:53] is very important that we stand out
[15:55] against a lot of other uh code
[15:57] generation tools. And it's very
[15:59] important for our customer to be uh to
[16:02] have really beautiful websites that they
[16:04] can use to sell to their uh customers.
[16:07] So Cognition, for example, uses to sell
[16:09] to a lot of enterprises. And so it's
[16:11] very important that the websites they
[16:13] use aren't these like purple websites
[16:15] with the purple gradient and the rounded
[16:17] corners um that are very common among um
[16:21] you know, um model generated content. So
[16:25] if our engineers don't have taste, then
[16:27] the product of what they're building
[16:29] will be creating things that don't have
[16:30] taste either, which would be bad for our
[16:33] end uh business impact.
[16:36] So I think that um taste has those two
[16:39] the two elements to me uh uh to be able
[16:41] to
[16:43] I mean, two two ways to train it. So one
[16:45] I think we haven't quite mentioned yet
[16:47] is um exposure.
[16:49] So it's very important to uh to us that
[16:52] our engineers are spending a lot of time
[16:54] trying out different products. So when
[16:56] I'm thinking like different products,
[16:58] it's not just like uh the software
[17:00] products like using linear all the time
[17:01] and learning all these like amazing
[17:03] things that linear does, but it's also
[17:04] trying out really cool physical products
[17:07] like looking at a MacBook and seeing how
[17:09] beautiful it it's packaged or like even
[17:12] thinking about like restaurant
[17:13] experiences, you know, what makes it
[17:15] amazing. For me personally, I watch a
[17:18] movie every week and I'm able to because
[17:21] I'm able to see a lot of different
[17:23] examples of good film, I'm able to see
[17:24] the nuances in what's good taste and
[17:26] what's bad taste. So very important for
[17:29] managers and I think this is the next
[17:31] question
[17:32] to ensure that like folks have enough
[17:34] time to spend time not just building
[17:35] their own product, but also being
[17:38] exposed to how other kinds of products
[17:40] work. And then the second element of
[17:42] taste is about building something that
[17:44] customers love. And it's very important
[17:46] to talk to customers in order to figure
[17:48] out what customers love.
[17:51] So you did anticipate my next question
[17:53] which is around the coaching, the
[17:54] management. Like a lot of folks in the
[17:56] audience are on the management side and
[17:58] have teams.
[17:59] How can you create rituals or best
[18:02] practices or exposure with your teams to
[18:05] build this product engineering muscle
[18:07] and and almost train a collective sense
[18:09] of taste?
[18:11] Yeah, so
[18:13] I think first one is to hire people who
[18:15] have taste and we've touched on it as
[18:17] well because it really infects everyone
[18:19] around you.
[18:20] Our designer was the head of design at
[18:22] Netflix and every time we come up with
[18:24] an idea that like maybe it's a
[18:25] short-term incremental improvement,
[18:28] she's like, "No. How do we make this
[18:30] magic? Can we push the boundary? Do we
[18:33] really want to have this same feature
[18:35] that all of the other tools have?" So if
[18:38] you have someone who's always pushing
[18:39] the bar for magic, it would infect
[18:42] everyone around you.
[18:43] I think the second one in terms of our
[18:46] how our company works is that we
[18:49] have this Slack channel called agentic
[18:52] development
[18:53] and people are just encouraged to share
[18:56] what they're learning about the world,
[18:58] different AI products, different like AI
[18:59] engineering techniques and then putting
[19:01] in the channel. And we are encouraging
[19:04] people to talk a lot about it. Sometimes
[19:06] people might spend like an hour or two
[19:08] discussing other people's products or
[19:10] like agentic development and we think
[19:12] that that is very good.
[19:14] Um and we
[19:15] are not cheap when it comes to helping
[19:18] our our our engineers pay for the tools.
[19:21] Like it's okay to spend some money on AI
[19:24] tools if it means you can learn
[19:25] something new.
[19:29] So, I've never been a manager, and I
[19:32] probably never will be, but um
[19:35] I was on API review at Stripe for a
[19:37] number of years, and
[19:39] one of And so, what that was was like a
[19:41] sort of a centralized body of people who
[19:43] would buddy up with different teams who
[19:45] were building new products, and then we
[19:47] would review their APIs. And of course,
[19:48] we checked for things like consistency,
[19:51] but one of the things that I added to
[19:52] the to the process was um
[19:55] a like a developer flows section of the
[19:57] the template. And it basically asked
[19:59] people who were submitting API designs
[20:00] to take me through a journey of like
[20:02] what is what is the developer doing with
[20:04] this API, you know, step by step. Like
[20:06] for like how are they getting the inputs
[20:08] to it, and then like how are they why
[20:09] are what what why are they calling it,
[20:11] and then calling it, and then just
[20:13] showing kind of a sketch of like how
[20:14] that story would progress.
[20:16] And that did two things is one, it got
[20:19] engineers thinking in terms of their
[20:20] users and how they'd experience it. And
[20:23] a lot of engineers weren't really
[20:25] good at writing developer flows. Like
[20:27] it's a skill that you have to learn, and
[20:28] so we would help them um kind of make
[20:30] bushier and bushier stories.
[20:33] And then the second thing is it helped
[20:34] us understand what they were doing
[20:35] because we weren't working on their
[20:37] product, but we were being asked to
[20:39] review, you know, code from different
[20:41] organizations. And so, these stories
[20:43] became a medium of communication where
[20:45] they could quickly brain dump us on what
[20:46] they were doing, and then we could do a
[20:48] good job of reviewing it.
[20:49] Um
[20:51] but uh in a lot of times what happened
[20:52] is actually as they wrote the stories,
[20:53] they figured out the the the problems
[20:55] themselves, and then they didn't have to
[20:56] talk to us.
[20:58] And then um
[21:00] and so, I I do think that stories are a
[21:02] great sort of medium of communication.
[21:04] Uh Michelle Bu, who's like a principal
[21:05] engineer at at Stripe and works on the
[21:06] APIs.
[21:08] Um, built a use case compendium for her
[21:11] her org, which was like,
[21:13] you know, the the North Star scenarios
[21:15] of like, here's the scenarios that we're
[21:16] going after, and these are the scenarios
[21:19] that like
[21:20] we're going to evaluate the success of
[21:22] our product by how well we like map our
[21:25] our system to these to these scenarios.
[21:28] And it sort of just grew over time, and
[21:29] so
[21:30] again, it's just sort of a shared
[21:32] communication medium for people to align
[21:33] everybody and get everybody thinking
[21:35] about their users.
[21:37] We have this thing called some quality
[21:39] Wednesdays that we do. And maybe that's
[21:41] again on the sort of, you know,
[21:42] implementation quality side of things.
[21:44] It all started when when sort of I got
[21:46] frustrated maybe 3 years ago cuz we we
[21:48] have this thing with highlights in the
[21:50] application. Like when you hover over
[21:51] something, it highlights instantly. And
[21:53] when you hover out, there it needs to be
[21:55] a fade out of 150 milliseconds, exactly.
[21:58] Cuz that's how we defined it, and
[21:59] that's, you know, it it it it works
[22:01] nicely and it feels good. And after the
[22:04] 10th time I I fixed one of these
[22:05] highlights not fading out, I was like, I
[22:07] I got to teach the team to sort of see
[22:09] these see these mistakes because if you
[22:11] don't know what you're looking for, like
[22:13] you will just simply miss it, and you
[22:14] won't you won't even know that you made
[22:15] a mistake.
[22:17] So, we did this thing where I I selected
[22:20] a few places in the application where I
[22:21] saw a few problems, you know, very small
[22:23] ones, and and off site we went through
[22:26] with a team, and I just asked them to
[22:28] like just focus on this
[22:30] portion of the app,
[22:31] and then come up with fixes. Come up
[22:33] with, you know, all small small kinds of
[22:35] defects that we had. And to my surprise,
[22:38] people found many more bugs or not bugs,
[22:40] but defects than I had anticipated. Like
[22:42] I had like maybe seen four, and we got,
[22:45] you know, 20 out of a very small piece
[22:48] of the application.
[22:49] And that led to the next idea, which is
[22:51] the quality Wednesday part, which is
[22:52] like, well, you know, if if if
[22:54] collectively we find all these defects
[22:56] in in the application, maybe we need to
[22:57] do it, you know, every single week. So,
[23:00] we started doing this where every single
[23:02] engineer is expected to just find a new
[23:04] defect um in the application, which is
[23:06] separate from a bug. Bugs we fix
[23:08] immediately, but a defect where some
[23:10] misalignment is there or a highlight is
[23:12] is missing or doesn't look right, um and
[23:15] then fix it and present it to everybody
[23:17] else. Um and we we started doing that 2
[23:19] years ago.
[23:20] We fixed probably like 2,500 defects. Um
[23:23] and I I I would be horrified to sort of
[23:25] see the application now it would would
[23:27] feel like if if you hadn't done all
[23:28] those fixes, but more importantly it
[23:31] sort of sets this precedent of um you're
[23:33] always on the lookout for your next fix.
[23:35] Like you're always looking at the
[23:36] product of like, "Oh, is it broken?
[23:37] Where is it broken?" cuz I need to, you
[23:39] know, find my next fix fix for next
[23:41] Wednesday. So it sets your mind up into
[23:43] sort of this this, you know, bug finding
[23:45] mode or defect finding mode, um and that
[23:48] helps you become a a better product
[23:49] engineer.
[23:50] I love that. I think it's good to
[23:52] present it, too, and celebrate it and
[23:53] kind of give it some visibility.
[23:55] >> teach everybody cuz like you will find
[23:57] things that other others haven't found.
[23:59] Yeah. Well, that's great. Great. That's
[24:00] great. Um switching gears slightly, so
[24:02] this can't be a conversation in 2026
[24:04] without talking about AI, obviously. How
[24:08] have kind of the new tools changed the
[24:10] workflow of product engineer and made it
[24:13] easier to be a product engineer or just
[24:15] kind of made that whole workflow look
[24:17] different in your eyes? And how how have
[24:19] your personal workflows changed?
[24:22] Yeah, so talking about
[24:23] about Wednesdays, um we had this thing
[24:26] at Warp called product quality rotation.
[24:29] Um so every week there will be one
[24:30] engineer who's in charge of like fixing
[24:33] all of the po- like polish issues and
[24:35] bug issues. And uh as a result, um Warp
[24:39] is a very fun to use uh product. Um
[24:43] But what I found that found is different
[24:45] now is that in 2026,
[24:48] um you no longer need to wait for a week
[24:50] and get one person to synchronously work
[24:52] on uh this workstream. Um each of the
[24:55] engineers at Flint right now typically
[24:57] has around four Claude code agents
[24:59] running at any time. So during stand up
[25:02] they would say, "My primary task for
[25:03] today is XYZ and in the background I'm
[25:07] running ABC." And what this means is
[25:10] that like a lot of like small fixes to
[25:13] the
[25:13] to the product actually gets fixed
[25:15] throughout the day by everybody.
[25:17] Um and then the other thing that I tend
[25:20] to do myself within my team is that um I
[25:23] often would have um sales calls between
[25:25] like 8:00 a.m. and 7:00.
[25:27] And so I would um have the uh sales call
[25:30] recordings automatically post into
[25:33] uh this Slack channel um including like
[25:35] any bugs that like people that I found
[25:37] during customer calls.
[25:39] And typically my um engineers would then
[25:42] like look through the summary and then
[25:43] automatically kick off Claude to start
[25:45] fixing some of the bugs. And it's really
[25:47] incredible because sometimes I would see
[25:49] a bug happen at 8:00 a.m. and then by
[25:51] 11:00 a.m. uh it's already fixed. Um so
[25:55] use a lot of call recording uh
[25:57] uh software, use a lot of summary
[25:59] software, um use Claude and also uh at
[26:02] Linear within Slack because some bugs
[26:05] are just like a lot bigger than
[26:06] something that Claude could just solve
[26:07] immediately. So when I see that it's
[26:09] more of like an architectural issue that
[26:11] we need to fix, I will at Linear make a
[26:13] ticket. Um and then we'll prioritize the
[26:15] next week.
[26:19] Yeah, um
[26:21] the I mean obviously the the feedback
[26:23] loop is getting much shorter which makes
[26:24] it it's so much more fun to iterate. If
[26:26] you know that it's going to take you 6
[26:28] months to fix any bug that a user is
[26:30] going to report, then why would you
[26:31] bother even talking to users?
[26:33] And so you know that instant
[26:35] gratification of being able to fix a bug
[26:37] so quickly is great and um in addition I
[26:41] think the AIs are starting to help with
[26:43] actual product skills as well. So my
[26:46] product team at Temporal, we have a
[26:49] um a bunch of like Claude's PM skills
[26:52] like competitive analysis or like maybe
[26:55] a big one for product engineers would be
[26:57] customer signal. Like, "Hey, I have this
[26:58] idea to like build such and such a
[27:01] feature. Find me users who would
[27:04] actually like have asked for that or
[27:07] something similar or would be people
[27:09] that I should reach out to, right?" And
[27:10] then it can just like list, you know,
[27:12] the Slack for them and the or the the
[27:15] email and and and then like you know,
[27:18] site from the Gong call or the GitHub
[27:21] issue or or the Slack channel and it
[27:24] support interaction. And just yeah, so
[27:28] so tools on the like like that connect
[27:30] people to users.
[27:32] Um I was recently uh my the car company
[27:36] for the car I drive, they they set up an
[27:38] email address
[27:40] that people can just complain to that
[27:41] email address about their cars. And then
[27:44] they have an AI kind of like sift
[27:46] through all the emails that are coming
[27:47] in because obviously it wouldn't scale.
[27:50] Um but now like we have ways to actually
[27:51] scale our interactions with customers
[27:54] and not have it feel like an
[27:55] overwhelming amount of noise, especially
[27:58] if you're in a like consumer if you're
[28:00] on a consumer product, but even if
[28:01] you're on a a business product as well.
[28:03] Um
[28:04] and so that the the signal to noise the
[28:07] denoising of the the user impact input,
[28:10] I think it's really going to help
[28:12] product engineers like be motivated to
[28:14] go in more in that direction rather than
[28:16] be like recoil in horror when they think
[28:18] about their users.
[28:20] Yeah, definitely. Like all of these
[28:21] things that that were that were said
[28:23] before, but um additionally maybe like
[28:25] the the the one thing that I I think has
[28:27] changed radically is
[28:28] um the fact that you can just try out
[28:30] things without really any effort. Um
[28:33] like there there might have been cases
[28:34] before where you get some, you know,
[28:37] some some design that looks super
[28:39] complicated and you you you have a hunch
[28:41] that it might not work, but you know,
[28:43] maybe it does. Like maybe it feels good
[28:44] if you implement it, but the
[28:46] implementation would take a week. Um,
[28:48] you wouldn't really sort of even try,
[28:50] like you would ask the designer to sort
[28:51] of make some changes or or, you know,
[28:53] reconfigure it. But now you can actually
[28:55] just give it a try and and see how it
[28:56] actually works in production and it's
[28:58] not only for product engineers, it's
[29:00] designers as well. Like we we we do have
[29:01] multiple designers who, you know, take
[29:03] their designs to the next level where
[29:05] they're like, "Oh, I want to try it out
[29:06] on the product." And they just spin up
[29:08] Cloud and, you know, have it um
[29:11] have it implement uh the designs that
[29:13] they do and then ship it in not ship it
[29:14] in production, but as a preview build so
[29:16] that they can actually, you know,
[29:19] use their designs um that they have and
[29:21] um that's a that's a huge, you know,
[29:23] benefit for for any engineer and
[29:25] designer. That That's happening at our
[29:27] company as well. So, our designer um is
[29:29] like formerly head of design at Netflix,
[29:32] has like a career of 12 years, never
[29:34] coded in her life. And it used to be
[29:37] that a designer would look at all these
[29:39] like, you know, borders that are not
[29:40] perfect or the greys that are a little
[29:42] bit off um or like a hard-to-find
[29:45] features, bad information architecture,
[29:47] and then she'll maybe like form like a
[29:48] few tickets for the engineering uh staff
[29:51] to take over at some point. Um, she's
[29:53] she's writing so many PRs now um maybe
[29:56] five to six a week um and uh
[29:58] the UX of the product just keeps getting
[30:01] better and better every week because now
[30:03] uh you're no longer just having like
[30:05] pure engineers uh writing code.
[30:08] We've noticed that, too. At I think
[30:10] probably like Q3 of last year, I got a
[30:12] freaked out call from our head of
[30:13] engineering being like, "Your designers
[30:15] and PMs are shipping code." And I was
[30:16] like, "That's great." And now it's like,
[30:18] "Oh, the designers and PMs are shipping
[30:20] code. This is awesome." Like the
[30:21] product's just automatically getting
[30:22] better as a result. Um, it's just cool
[30:24] to see how that attitude has evolved in
[30:26] real time.
[30:27] Um, okay. So, in the last kind of 2
[30:29] minutes, just any parting wisdom for
[30:31] this group, either from a IC perspective
[30:34] of how to become a better product
[30:35] engineer or how to coach better kind of
[30:37] product engineering instincts amongst
[30:39] your teams.
[30:41] And then we'll go over to audience Q&A.
[30:44] Yeah, I think that there's um no
[30:46] substitute for uh talking to customers
[30:48] directly. Uh you should totally use AI
[30:51] summarization tools, but there's just
[30:52] something about like a human meeting
[30:54] another human that really develops
[30:56] empathy in a way that reading a summary
[30:58] summary of calls would never do. So, um
[31:01] it is important to me to uh bring my
[31:04] engineers to customer uh site visits,
[31:06] and then I also make sure that um
[31:08] every engineer attends at least one
[31:09] sales call with me every week.
[31:11] Love that.
[31:13] As a leader, I would uh
[31:15] again, with the caveat that I haven't
[31:18] uh
[31:18] but um but as a tech lead, I I typically
[31:21] um
[31:22] like I I my my advice would be to like
[31:25] run the gradient from
[31:28] vanity metrics to adoption metrics to
[31:30] like metrics that really it capture val-
[31:33] like the value that users are getting
[31:34] out of it, and then goal your engineers
[31:36] on those metrics.
[31:38] You know, just to take an example of a
[31:40] social network, you've got your vanity
[31:41] met- metric, which is like all-time
[31:43] sign-ups. It's like, "Well, MySpace is
[31:45] like huge on this metric, right?" And
[31:47] then you like align it a little bit
[31:49] more, you make Okay, maybe it's a
[31:51] monthly active user, right? And that
[31:53] user is coming back, which is some
[31:54] indication that they're getting value
[31:55] from the product, right? But
[31:57] or maybe they're just addicted, or maybe
[31:59] that's not it's it's it's not really
[32:01] giving you value. And so, then you
[32:02] think, "Okay, well, maybe
[32:03] time spent um like how much times time
[32:07] is this user spending?" And so, that
[32:08] obviously they wouldn't come back if
[32:10] they weren't
[32:10] weren't spending more time. Okay, well,
[32:12] but what if Yeah, again, what if they're
[32:14] just re- watching AI slop, or what if
[32:16] they're addicted? Um
[32:18] so, then you start looking at, you know,
[32:20] meaningful interactions like choices
[32:22] that they're making, comments and likes,
[32:25] posts, like thing like connecting with
[32:27] friends, like things things that are
[32:28] like you have decided quantitatively are
[32:31] like more meaningful.
[32:32] Um or you you know, even better, like
[32:35] you you ask you you survey users, and
[32:37] you ask them like you know, maybe
[32:39] counterfactual questions like how much
[32:41] how much money would you have to be paid
[32:43] to not use this this social network or
[32:46] you know, how you know, at Stripe there
[32:48] was a question that we asked users like
[32:50] would your
[32:52] would your company exist without Stripe?
[32:54] And and the answer like in you know, a
[32:56] few years ago was surprisingly often
[32:58] like no, like we couldn't have
[33:00] bootstrapped um our company without this
[33:02] product. That's a real indication of
[33:04] value, right? And so, if you can um
[33:08] you know, but the problem is of course
[33:09] the further you get along that gradient,
[33:10] the harder it is to measure and the
[33:11] longer it takes to measure it. But you
[33:13] so therefore you have to be a bit
[33:14] obsessed obsessive about finding those
[33:16] ways to to measure real value and then
[33:19] like
[33:20] you know, tying it to the performance
[33:21] reviews of your
[33:23] of your especially your more senior
[33:24] engineers.
[33:27] Um maybe some advice to the EMs. Um like
[33:30] give your give your engineers time to to
[33:32] you know, create a high quality product.
[33:35] Um it it it sounds you know, simple and
[33:37] stupid, but there's no AB test that sort
[33:39] of will you know, let you know whether
[33:41] you're building a high quality product
[33:43] cuz quality is not measurable sort of
[33:45] quickly. Um like if you don't think
[33:47] about quality, your your your product
[33:49] will degrade over time. So a year later
[33:51] maybe um you will have a lower quality
[33:53] product and you use this one a month and
[33:55] you for for somebody else if you don't
[33:57] do that. Um and I can assure you that
[33:59] engineers will want to take that time
[34:01] cuz they want to be proud in their work.
[34:03] They want to make sure that they have
[34:04] enough time to sort of ship something
[34:05] that they can be proud of. Um
[34:08] I had this thing at Uber I used to be at
[34:09] Uber a mobile engineer um and a few
[34:12] years ago like I I opened the app after
[34:14] a long time and I was I was devastated
[34:17] by all the bugs that I found. I was like
[34:19] I I could spot like 10 bugs in 10
[34:21] seconds. Um and I just tweeted
[34:22] frustrating frustrated I tweeted out
[34:25] saying like what happened? Like why we
[34:27] we we used to care about these things.
[34:30] Um and that you know, created a stir at
[34:32] Uber and they they had a code yellow and
[34:34] they started fixing bugs.
[34:36] Um, and engineers started tweeting back,
[34:38] DMing me back saying, "Thank you. Thank
[34:40] you for for raising this from the
[34:42] outside and having our managers give us
[34:44] the time to to fix these bugs."