Chats with Kent C. Dodds

Kent closes Chats with Kent season 7 and explains what changes on this feed: Become a Product Engineer is now its own podcast, with season 7 episodes and upcoming releases on that RSS feed. He previews guests still in the pipeline and introduces Better with Kent, a new solo series on durable skills for software engineers.

Season 7 of Chats with Kent is over. The interview series you have been following as Become a Product Engineer has graduated into its own show. Kent may do another Chats with Kent season later, but for now this episode is the season 7 finale on the Chats with Kent feed.

If you have been subscribed here, you do not need to re-listen to old episodes to catch up. The season 7 conversations are already on the new podcast, and the episodes Kent mentions below are scheduled on that feed going forward.

Still coming on Become a Product Engineer (among others):

Jack Ryan (Intercom) - user empathy, feedback loops, and what not to build

Swizec Teller - user outcomes, workflow design, and biotech software

Grady Booch - software architecture, human judgment, and AI's limits (including Kent's "Last Software Engineer" framing)

Sean Roberts - the technical person in the room and how product engineering differs from product management

Ruben Casas - demos, feedback loops, and judgment in the AI product era

Lucas Varga (FamilySearch) - helping engineers grow into product engineers

Kent is also starting Better with Kent: solo episodes on durable skills - judgment, accountability, empathy, and what stays valuable as AI takes on more implementation - on YouTube and in podcast apps.

Homework

Subscribe to Become a Product Engineer in your favorite podcast app so you do not miss upcoming guest episodes.

Subscribe to Better with Kent on YouTube or your podcast player for the new solo series.

If you have not moved yet, open the Become a Product Engineer feed once and confirm you see the season 7 episodes you have already heard - then stay subscribed there for new releases.

Resources

Become a Product Engineer podcast

Better with Kent

Chats with Kent (call in)

Host: Kent C. Dodds

Website: kentcdodds.com

𝕏: @kentcdodds

GitHub: @kentcdodds

YouTube: Kent C. Dodds

Podcast: epicproduct.engineer

Rhys has an unusually current perspective on product engineering because he is working right at the edge of the agent tooling shift. The conversation starts with his recent work on Vercel Domains and then moves into Executor, where the challenge is no longer just implementing integrations, but choosing the abstractions that make a system composable, safe, and pleasant to use over time.

What makes the episode strong is how often it comes back to product judgment instead of novelty. Rhys and Kent talk about finding the right primitives, observing how other products solve hard UX problems, resisting the urge to ship every request immediately, and building systems that help agents without letting them become dangerously "helpful."

Homework

Create a dedicated notes channel or system where you save examples of products doing something well.

Use those notes as reusable product input: when you need to build a flow later, pull the examples back up instead of starting from scratch.

Resources

Executor

Rhys Sullivan — site

Executor — GitHub

OpenCode

Guest: Rhys Sullivan

Company: Executor

GitHub: @RhysSullivan

𝕏: @RhysSullivan

Host: Kent C. Dodds

Website: kentcdodds.com

𝕏: @kentcdodds

GitHub: @kentcdodds

YouTube: Kent C. Dodds

Video

Watch this episode on YouTube

Alex brings a product and marketing lens that fits this season perfectly: great products do not just solve technical problems, they help the right people recognize that you understand their world. The conversation starts with finding an audience and quickly turns into a practical way to build product sense inside a company: learn how customers describe themselves, observe where they gather, listen for the language they use, and speak from their priorities instead of your own taste.

The second half gets into Sales Safari, Stacking the Bricks' observational research practice. Alex explains why surveys and interviews can miss important signal, what to look for in real conversations, and how notes on jargon, pain, worldview, and recommendations can turn scattered internet conversations into useful product understanding. The through-line is simple and demanding: reduce the distance between you and the people you serve so your software, messaging, and decisions feel anticipated rather than manipulative.

Homework

The next time coworkers or product teammates disagree about direction, step back and observe the conversation.

Ask: who is this disagreement in service of? Is it serving the customer, the decision maker, the loudest person, or someone else?

Practice this once a day or once a week, then use the patterns you notice to decide what you should contribute.

Resources

Stacking the Bricks

30x500

The Tiny MBA

The Mom Test

Alex Hillman on X

Guest: Alex Hillman

Company: Stacking the Bricks

GitHub: @alexknowshtml

𝕏: @alexhillman

Host: Kent C. Dodds

Website: kentcdodds.com

𝕏: @kentcdodds

GitHub: @kentcdodds

YouTube: Kent C. Dodds

Video

Watch this episode on YouTube

Julius is building right in the middle of one of the fastest-moving product categories in software, and that gives this episode a useful tension: everything feels possible, but that does not mean everything belongs in the product. The conversation covers the shift from one-agent-at-a-time coding to orchestration, why T3 Code focuses so much on a fast app layer, and how Julius thinks about what should live in the core product versus forks, plugins, or future work.

The deeper lesson is about judgment under speed. Julius and Kent keep returning to the same idea from different angles: when agents can generate a lot of implementation quickly, the real work is deciding what is worth building, what will age well, and what future decisions you might accidentally box yourself out of.

Homework

Take a step back and look at your product from the whole picture, not just the slice you currently touch.

Before prioritizing a feature, ask whether it keeps the product maintainable long-term and whether it fits the job to be done for your users.

Resources

T3 Code

T3 Chat

Julius Marminge — GitHub

OpenCode

Guest: Julius Marminge

GitHub: @juliusmarminge

𝕏: @jullerino

Host: Kent C. Dodds

Website: kentcdodds.com

𝕏: @kentcdodds

GitHub: @kentcdodds

YouTube: Kent C. Dodds

Video

Watch this episode on YouTube

Jamon brings a useful mix to this conversation: founder of Infinite Red, longtime consultant, React Native specialist, and now indie game developer. That perspective makes the episode unusually practical. He has spent years watching where projects go wrong when product thinking is weak: bad requirements, unclear stakeholder alignment, UX details nobody owned, and engineers optimizing the wrong thing too early.

The thread through the whole episode is durability. Product engineering is not just about shipping faster with agents or getting better at a specific tool. It is about understanding people, shaping better requirements, recognizing when the human side of the workflow matters more than the code, and making decisions that keep paying off as the technology changes around you.

Homework

Sit down with a non-technical person and watch them try to use a feature you built.

Write down every hesitation, workaround, double-click, or confusing step you notice, then use that list to reprioritize what you fix next.

Resources

Infinite Red

Jamon Holmgren — site

Night Shift Agentic Workflow

Gunship Origins on Steam

Guest: Jamon Holmgren

Company: Infinite Red

GitHub: @jamonholmgren

𝕏: @jamonholmgren

Host: Kent C. Dodds

Website: kentcdodds.com

𝕏: @kentcdodds

GitHub: @kentcdodds

YouTube: Kent C. Dodds

Video

Watch this episode on YouTube