Advertise on podcast: Chats with Kent C. Dodds

Don's career makes this episode unusually wide-ranging: early computing, human error, aviation safety, Unix, Apple product decisions, digital cameras, color TV, and the long arc from usable products to systems that shape society. The through-line is straightforward but demanding: if you want better products, watch what people actually do, notice the workarounds they no longer complain about, and treat clusters of small usability problems like real product debt. The second half brings that thinking into the present. Don and Kent talk about AI coding tools as force multipliers that still need direction, architecture, and supervision, then zoom out to Design for a Better World and the Don Norman Design Award. The result is a conversation about product sense that spans decades without feeling dated: the tools change, but the responsibility to understand people, systems, and consequences does not. Homework Spend time watching people do real work before you ask them for solutions; observation reveals the hidden setup, workarounds, and friction they now assume are just "how it works." After a release, step back and fix clusters of small usability issues as a system instead of waiting for one confusing bug to become catastrophic. Treat AI as a force multiplier you must instruct and supervise; stay responsible for the problem definition, architecture, and review. Resources Don Norman Design Award (DNDA) Design for a Better World The Design of Everyday Things Nielsen Norman Group — Don Norman United Nations Sustainable Development Goals Guest: Don Norman Company: Don Norman Design Award (DNDA) Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds Youtube: Kent C. Dodds Video Watch this episode on YouTube

Will's path runs from designing bucket trucks to self-taught software engineering, education products, and database tooling, and that background gives this episode a distinctive lens: software is still a product people use with bodies, habits, emotions, and mental models. The conversation makes product sense concrete through examples like onboarding timing, course complexity, support workflows, and the small confidence signals that separate stable-feeling products from merely functional ones. You'll hear why watching users work keeps surfacing across this series, how to tell broken experiences from merely unpopular ones, why user feedback usually improves polish more than strategy, and how product engineers can stay valuable in an agent-heavy future by understanding both the user and the constraints of the software medium. Homework Use AI agents more for gathering than executing: explore multiple solution paths, adjacent domains, and missing context before you ship. Give agents richer context like user demographics, constraints, and likely mental models, then use your own judgment to evaluate what comes back. Slow down long enough to question assumptions before implementation; use AI as a creativity and critique tool, not just a code accelerator. Resources Will King - site Deploy Empathy (Michele Hansen) The Mom Test (Rob Fitzpatrick) Interface Craft (Josh Puckett) Guest: Will King Company: Crunchy Data GitHub: @wking-io 𝕏: @wking__ Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds Youtube: Kent C. Dodds Video Watch this episode on YouTube

Aaron builds in public—Laravel roots, education, and now Solo, a terminal multiplexer–style desktop app for organizing agents and dev stacks. This episode is a practical tour of product sense for developers: watching people work, reading support email with empathy, cow paths vs. fences, and why the “right” architecture can still lose if humans go home furious. You’ll hear how Aaron reasons from problem → solution when users ask for worktrees, when to duplicate UI affordances even when the model is “one,” and how introverts can still do discovery by treating outreach like an optimization mission—plus niche opportunities outside the Cursor clone gold rush. Homework When someone asks for a solution (e.g. a feature), slow down and ask what problem they’re really trying to solve—users often lead with implementations. Practice user empathy: imagine someone stressed, trying to finish work; question “technically correct” UX that blames the user instead of protecting them (confirmations, back-button data loss, etc.). If talking to people is hard, reframe discovery as a systematic search (spreadsheet energy, trusted partners, or domain friends)—or pair with someone who loves conversations. Resources Aaron D. Francis — X Jobs to Be Done (Clay Christensen) The Design of Everyday Things (Don Norman) Guest: Aaron D. Francis Company: Solo & Laravel education GitHub: @aarondfrancis 𝕏: @aarondfrancis Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds Youtube: Kent C. Dodds Video Watch this episode on YouTube

Dillon's path runs from internal insurance tools to Vercel Domains to Cloudflare's agent and dashboard work-always with the same through-line: care about the user, get real feedback, and invest in primitives so delighters don't collapse under bad foundations. This episode covers metrics and paging as a product habit, learning from customer escalations, scoping small when AI speeds up coding, and building cross-functional relationships (support, sales, finance) as part of engineering judgment. You'll hear practical parallels with episodes on delighters and onboarding tension, plus why reviewing agent-written code still matters for system intuition when things break at 2 a.m. Homework Try hard and care a lot; more practically, focus on foundations and primitives. Put good feedback systems in place so you know what's going on with your product and where it doesn't feel good-alerting and metrics, customer journey signals, or customer interviews. If you have a customer support team, sit with them and watch them triage cases for your product; get to know support-they're sitting on a gold mine of product signal-and empathize with them like you do with users. Kent's shorthand for the mindset Dillon agreed with: make pain painful-if your users are hurting, you should feel it too. Resources Cloudflare - Developers Cloudflare Agents Dillon Mulroy - site Dillon Mulroy - GitHub Guest: Dillon Mulroy Company: Cloudflare GitHub: @dmmulroy X: @dillon_mulroy Host: Kent C. Dodds Website: kentcdodds.com X: @kentcdodds GitHub: @kentcdodds Youtube: Kent C. Dodds Video Watch this episode on YouTube

Wayne blends delivery and product leadership—his stories range from a flagship-adjacent launch that nobody used to the everyday discipline of listening to customers without waiting two weeks for a meeting. This episode connects feedback-loop thinking (familiar from CI) to product discovery, yes-and conversations when someone is married to a feature idea, and the difference between hygiene features, performance features, and delighters when teams ship faster than users can absorb. You'll also hear grounded takes on when "move fast" breaks trust, how AI may reshape search-and-listing UIs, and a concrete reading list: The Mom Test and Crossing the Chasm. Homework Talk to people, ask good questions, and listen—Wayne says that's the biggest hack that's worked in his career. Read The Mom Test: ask how people solved this problem in the past instead of whether they like your idea or would use it—you get far more useful insight (Wayne ties this to caring about the problem, not your solution). Resources The Mom Test (Rob Fitzpatrick) Crossing the Chasm (Geoffrey Moore) Thoughtworks Wayne Allan — LinkedIn Guest: Wayne Allan Company: Thoughtworks 𝕏: @xWayfinder Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds Youtube: Kent C. Dodds Video Watch this episode on YouTube

Dax has spent years building tools developers actually use; on OpenCode he's thinking hard about product process while the space moves at breakneck speed. This episode is a practical look at product deterioration (not just code rot), bottom-up adoption for dev tools, and how coding agents change who decides what gets built—without replacing the need for taste, restraint, and clarity about what problem you're solving. You'll hear concrete examples from OpenCode's terminal UI and onboarding, parallels to Kent's Epic Workshop app, and a grounded take on inference pricing, hype, and when "ship messy and fix later" does and doesn't hold up. Homework Convince yourself that getting good at product really matters—Dax says there's a lot in the culture that tries to tell you it doesn't, and you need that commitment because the belief will be challenged. If you don't already believe it, figure out how to make yourself believe it matters (Kent's recap of the guest's action). Resources OpenCode OpenCode docs Dax Raad (site) Kent C. Dodds — blog Guest: Dax Raad Company: OpenCode GitHub: @thdxr X: @thdxr Host: Kent C. Dodds Website: kentcdodds.com X: @kentcdodds GitHub: @kentcdodds Youtube: Kent C. Dodds Video Watch this episode on YouTube

Software keeps changing, and a lot of the spotlight is on AI—but the shift Kent cares about is bigger than models and agents. Implementation is increasingly delegated to tools that will keep improving; quality, review, and craft still matter, but the gap that won’t go away is product: understanding users, clarifying problems, and shipping what actually helps. This season is a deliberate tour of product engineering: conversations with people who blend product judgment with technical depth—including PMs and engineers who’ve crossed that line. The goal is the same as it’s always been for Kent’s teaching: give you durable skills. Right now, that means leveling up how you think about product, not just how you type code. Homework Write down one product decision you influenced (or wish you had) in the last month—what would you validate earlier next time? Pick an app you use weekly: what problem is it really solving for you, and where does it feel like the team lost the plot? Subscribe or follow Chats with Kent so you don’t miss the guest episodes in season 7. Resources Chats with Kent on kentcdodds.com Video Watch this on YouTube

Kent says goodbye at the end of another season of the "Chats with Kent" podcast, which featured interviews with speakers for the upcoming Epic Web Comp 2025 conference in Salt Lake City. The host, Kent C. Dodds, expresses excitement about the lineup of speakers and encourages listeners to attend the conference in March 2025. He also mentions that the talks will be available on the EpicWeb.dev platform for those who miss the live event. Meet at Epic Web Conf. Guest: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev

Kent C. Dodds sits down with Jason Lengstorf to discuss his talk at Epic Web Conf, Of Things Epic, where he dives into the principles behind effective decision-making in web development. Rather than focusing on which tools to pick, Kent emphasizes the need for a framework that enables developers to make confident decisions that scale. He draws from his experience with the Epic Stack, highlighting the importance of clear reasoning behind technical choices. Key topics in this conversation include: Why decision paralysis is unnecessary in modern web development. How the Epic Programming Principles provide a solid foundation for making smart tech choices. Why Laravel's opinionated approach has been so successful and what we can learn from it. The importance of structuring your projects so they can evolve without unnecessary rewrites. How in-person conferences create opportunities for career growth and deeper relationships. Kent also shares his excitement about the hallway track at Epic Web Conf, encouraging attendees to come talk to him about real-world experiences with the Epic Stack, scaling web apps, and even personal interests like family life, one-wheeling, and snowboarding. Watch this episode. Meet Kent at Epic Web Conf. Guest: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev Host: Jason Lengstorf Website: CodeTV.dev 𝕏: @jlengstorf GitHub: @jlengstorf YouTube: CodeTV

Andre Landgraf joins Kent to discuss his talk at Epic Web Conf, Epic Image Optimization. In this conversation, they explore the challenges and trade-offs of optimizing images for the web, particularly when handling large numbers of event photos or user-generated content. Andre shares how building his own image optimization pipeline gave him a deeper understanding of the process, allowing him to make more informed decisions when choosing external services. Kent and Andre also discuss: The evolution of All Things Web, a meetup Andre organizes in the Bay Area. The importance of community in web development and how in-person meetups have shaped his career. His experience working with Ember at LinkedIn and his upcoming career shift. Why diving deep into a problem—like image optimization—makes you a better engineer. How Epic Web Conf has become a must-attend event for those passionate about web technologies. Andre brings a wealth of experience and enthusiasm to the conversation, making this episode a must-listen for anyone looking to level up their approach to image handling in modern web applications. Watch this episode. Meet Andre at Epic Web Conf. Guest: Andre Landgraf Website: andrelandgraf.dev 𝕏: @andrelandgraf94 GitHub: @andrelandgraf Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev

In this conversation, Jason Lengstorf, creator of CodeTV and the Web Dev Challenge, joins Kent to discuss: His background in engineering, developer relations, and open-source at companies like IBM, Gatsby, and Netlify. The Web Dev Challenge, a fast-paced, team-based competition that brings developers together to solve unique coding challenges in just four hours. The free Epic Web Conf hackathon happening the day before the conference, where attendees can join the challenge, build something cool, and showcase their work. His philosophy on career growth, taking calculated risks, and building a career you truly enjoy. Why in-person conferences are critical for networking and how making friends, rather than “networking,” can be the key to long-term success. Jason shares why he prioritizes being in physical spaces with other developers, how meaningful relationships have shaped his career, and why he believes success comes from showing up, trying hard, and having the courage to take chances. Watch this episode. Meet Jason at Epic Web Conf. Guest: Jason Lengstorf 𝕏: @jlengstorf GitHub: @jlengstorf BlueSky: jason.energy Website: codetv.dev Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev

In this conversation, Ryan Florence, co-creator of Remix and React Router, joins Kent to talk about the evolving landscape of web development. He shares insights on: The motivation behind moving core Remix features into React Router. The rising importance of AI-driven development and how it affects frameworks. Betting on the web platform as a long-term strategy for performance, portability, and future-proofing applications. How Remix is being reimagined with a focus on web-native capabilities. The role of conferences in building meaningful career relationships. Ryan also shares his personal reflections on balancing career, family, and the desire to step back from the spotlight. Whether you're a Remix user, a React developer, or just curious about where the web is heading, this discussion offers a fascinating look at the future of frameworks and the web. Watch this episode. Meet Ryan at Epic Web Conf. Guest: Ryan Florence 𝕏: @ryanflorence GitHub: @ryanflorence Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev

Annie Sexton joins Kent to talk about her upcoming talk at Epic Web Conf, JavaScript: The Origin Story. In this discussion, she shares her love for history and why documenting the evolution of programming languages is so important. They dive into: The rushed creation of JavaScript and how it shaped the language. Competing languages of the era and how JavaScript won out. The unexpected ways JavaScript evolved into a web powerhouse. Why software history often gets overlooked and why it matters today. How understanding the past helps developers write better code for the future. Annie’s talk will be a must-watch for developers who want to gain a deeper appreciation of JavaScript and its unique journey. Expect to walk away with a richer perspective on the language that powers the modern web. Watch this episode. Meet Annie at Epic Web Conf. Guest: Annie Sexton 𝕏: @anniebabannie Website: anniesexton.com Bluesky: anniesexton.com Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev

Zackary Jackson joins Kent to discuss his upcoming talk at Epic Web Conf, Epic Federation: Scaling Web Infrastructure. As an expert in large-scale web architecture, Zack has helped build critical tools like Module Federation and RSPack, both of which power ByteDance’s global infrastructure. In this conversation, Kent and Zack cover: The challenges of managing thousands of developers and repos across multiple teams. Why ByteDance chose to build its own bundler in Rust instead of adopting an existing solution. The impact of slow build times on product velocity and how tooling improvements significantly reduce development friction. The role of Module Federation in solving organizational scale problems, allowing teams to ship independently. How AI-powered tools are shaping the next generation of developer workflows. Zack also shares his thoughts on why meeting open-source maintainers and industry leaders in person can unlock collaboration opportunities that aren’t as easily accessible online. Watch this episode. Meet Zackary at Epic Web Conf. Guest: Zackary Jackson 𝕏: @ScriptedAlchemy GitHub: @ScriptedAlchemy Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev

Aaron Francis joins Kent to discuss his talk at Epic Web Conf, Epic Bets: Practical Tips for Betting on Yourself. In this conversation, Aaron reflects on his non-traditional path into tech, his experience being laid off, and how he prepared himself to be resilient in the face of career uncertainty. He shares insights on why developers should focus on skill stacking, personal branding, and long-term sustainability in their careers rather than chasing trends. Kent and Aaron also explore: How to future-proof your career without falling into the trap of chasing hype. Why writing and sharing your knowledge can open unexpected doors. The importance of building a professional network before you need it. How to balance ambition with family life and personal values. Why giving your absolute best—both professionally and personally—is always worth it. Aaron’s perspective is both practical and inspiring, offering a roadmap for developers who want to take control of their future without sacrificing what truly matters. Watch this episode. Meet Aaron at Epic Web Conf. Guest: Aaron Francis 𝕏: @aarondfrancis GitHub: @aarondfrancis Website: aaronfrancis.com Host: Kent C. Dodds Website: kentcdodds.com 𝕏: @kentcdodds GitHub: @kentcdodds YouTube: Kent C. Dodds Epic Web: epicweb.dev