Better with Kent

Here's how the new MCP spec works

Kent C. Dodds — Thu, 20 Aug 2026 08:08:00 -0600

MCP is stateless now. Any instance can answer a tool call. Kent walks the 2026-07-28 release: sticky sessions vs a normal load balancer, CIMD vs DCR, multi-round-trip elicitations, and how to run both lanes until the metrics say you can drop the old one.

(00:00) - They fixed MCP
(01:13) - Better with Kent
(01:37) - Cloudflare + the dual-lane upgrade
(03:13) - MCP is now a stateless protocol
(03:25) - Sticky sessions vs any instance
(06:20) - Self-describing requests and headers
(07:17) - What else shipped
(08:24) - Formal deprecation policy
(10:05) - Roots, sampling, logging, SSE
(11:58) - Client ID metadata documents
(12:38) - How DCR used to work
(14:15) - Unbounded client registrations
(15:59) - The client ID is a URL
(18:33) - Multi-round-trip requests
(22:17) - Dual-lane until the metrics say so
(23:54) - Homework: instrument old cruft

Better with Kent - durable skills for people who ship software.

They fixed MCP. The people who called it a bad protocol have less of an excuse now. The 2026-07-28 spec is the biggest change since the beginning, and the headline is that MCP is a stateless protocol.

Kent walks the before-and-after. The old world needed a sticky session on one instance behind the load balancer. If that instance fell over, the client was stuck. The new world is ordinary HTTP: any instance can serve the request. App state can still live in a database. The transport session is what died.

That unlocks the rest of the release. Requests are self-describing. Method and tool names travel in Mcp-Method and Mcp-Name headers, so a gateway can route without reading the body. Multi-round-trip requests replace held-open SSE for elicitations: the server returns the input it needs, the connection closes, and the client can come back days later on any instance. List responses are cacheable. Extensions are formal now (MCP Apps, Tasks). DCR is deprecated in favor of Client ID Metadata Documents: the client_id is an HTTPS URL, trust is ownership of the domain, and you stop minting an unbounded registration record per reconnect. Kent's own early Kody numbers: about 125 DCR registrations per user.

There is a formal 12-month deprecation window. Roots, sampling, logging, and HTTP+SSE are on the way out. Kent is glad Roots is gone, a little sad about sampling, and fine with streaming replacing SSE.

The receipt is a dual-lane /mcp: Cloudflare's Agents SDK classifies isLegacyRequest, the new spec already shows up from Claude Code, and weekly agents watch the metrics. Homework is the durable move: instrument your old cruft so data, not a calendar, tells you when it is safe to remove.

Links

The craft "dying" is your OPPORTUNITY

Kent C. Dodds — Tue, 18 Aug 2026 08:18:00 -0600

People worry AI is destroying craft and making developers lazy. Kent says that is incomplete: most will hand judgment to the agent. The differentiators own the system, the UX, and what the agent learns to care about.

(00:00) - AI is destroying the craft?
(00:22) - Humans were never deterministic
(01:17) - Judgment was always easy to outsource
(02:27) - Your opportunity
(04:21) - Ownership is the job
(05:25) - Close the loop
(06:41) - Walk away from the code
(07:53) - Homework

Better with Kent - durable skills for people who ship software.

A lot of people are worried AI is destroying the craft and making developers lazy. Some of that is true. It is not the whole story.

LLMs are not compilers. They are not deterministic. Neither are humans. Slop and abdicated judgment are real. The idea that AI invented software bugs is not. People have always been happy to defer decisions: a library from a big company, a ticket from someone else, now an agent that will take the whole job if you let it.

That is the opportunity. Most developers will find it easier than ever to hand system design to the model. The people who stay in the loop, design the primitives, and keep ownership will be the ones who stand out.

Kent's own half-million-line codebase since March is a hint of the direction: spend less time on semicolons and framework nuances, more time on the software factory the agent works in. The agent mirrors what you care about. If you care about UX, cost, and sustainability, it will keep bringing those up. If you only care about closing the ticket, that is all you get.

Bugs are not new. GitHub Actions was down for eight hours. Humans still admit agent mistakes into the factory loop. Craft survives by designing primitives, not by reading every line. The agent amplifies you. It does not replace you. Users already expect more.

Homework: look at the corrections you give your agent. Are they marginally useful, or high-impact UX and system issues? Raise the bar to the ones that actually change the product.

Links

Stop Burning Your Context Cash

Kent C. Dodds — Thu, 13 Aug 2026 09:26:16 -0600

A giant AGENTS.md feels responsible. It is often just burning tokens. Kent walks the Claude Code 80% cut, a research paper that found +20% cost for little gain, a live prune of his own file, and homework: make the always-on file a router, not an encyclopedia.

(00:00) - Cold open: you're burning context dollars
(00:43) - Better with Kent intro
(00:59) - Claude Code cut 80% of the system prompt
(01:43) - When system prompt, skills, and user requests clash
(03:05) - Context engineering best practices that became myths
(04:12) - Avoid stating the obvious / progressive disclosure
(04:42) - You don't need useMemo for your agent
(05:36) - Performance optimizations are not free
(06:17) - Research: AGENTS.md often doesn't help (+20% cost)
(07:06) - The cargo-cult loop
(07:24) - Overstuffed AGENTS.md walkthroughs
(09:01) - If the agent can find it in the repo, cut it
(09:54) - Live prune of my own AGENTS.md
(14:05) - I audited 37 agents
(15:30) - AGENTS.md should be a router
(16:30) - Shrink always-on context
(18:30) - Homework: slim the always-on file
(19:54) - Close: get better together

Better with Kent - durable skills for people who ship software.

Stuffing AGENTS.md, CLAUDE.md, and auto-loaded skills because it feels responsible is the new useMemo-everywhere cargo cult. Context is not free. Claude Code cut about 80% of its system prompt for newer models. A research paper evaluating AGENTS.md found those files often do not improve task success while increasing inference cost by over 20%.

Kent walks real overstuffed files (discoverable repo trees, package managers, test commands the agent can find itself), then prunes his own Kody AGENTS.md live: keep what the repo is for, keep landmines, keep a short index, cut the rest. He audited 37 of his own agents from one day: 0 re-read AGENTS.md, 86% pulled docs and skills on demand, and most went straight to the leaf.

The durable skill: treat the always-on file as a tiny map. Progressively disclose the rest. Measure whether the extra tokens still help after the models change underneath you.

Homework: take 15-30 minutes with your agent. Rip out everything discoverable from the repo. Keep the gotchas that trip it every time. Index the rest. Delete docs nobody has opened.

Links

Use AI to make product decisions

Kent C. Dodds — Tue, 11 Aug 2026 09:20:00 -0600

Most people use agents to write code. Watch Kent use one to decide what to build: gather evidence, argue primitives, peel cleanup into side quests, keep the judgment - and only then type go.

(00:00) - Cold open: I think we are aligned, so let's go
(00:05) - Better with Kent intro
(00:24) - The durable skill: making a product decision with your agent
(00:31) - Start at the top: hand the agent the Agents Week post
(01:11) - Your agent needs a computer, not a container
(02:49) - Agent TLDR: opportunities and a workspace assistant primitive
(03:47) - How Kody repo sessions work today
(05:32) - Will King: use agents to gather, keep the judgment
(06:17) - Built-in primitive or community package?
(06:27) - Primitives are hard to remove once you add them
(07:37) - Entitlements, cost, and whether the business survives it
(09:16) - Ask for real usage data, not speculation
(10:38) - Push back when the data is wrong
(11:05) - Side quests: spawn other agents so the thread stays on the decision
(12:30) - A gap can mean expanding a primitive, not adding one
(13:34) - Durable objects vs R2: expertise that saved 13x
(15:17) - Catching the agent being sloppy
(15:47) - Artifacts is the better backing primitive
(17:39) - Least surprise is a product principle too
(18:08) - Research: large files in Cloudflare Artifacts (30 MB, 413s, no LFS)
(19:39) - Price-conscious prompts make price-conscious agents
(20:22) - The call: one repo primitive with a package marker
(21:10) - Progressive disclosure, then go
(21:52) - Why almost no skills for this conversation
(22:20) - Homework: ask for one research deliverable
(23:12) - Close: get better together

Better with Kent - durable skills for people who ship software.

A Cursor cloud agent is sitting mid-conversation and the next thing Kent types is one word: go. Before that, there is a whole product conversation worth watching - because none of it was "write the feature."

Cloudflare Agents Week drops @cloudflare/computer, and the real question is not "can we build it" but "what should Kody's primitives be?" Kent walks the actual thread: asking the agent to gather evidence instead of implementing, pushing back when the data is wrong, measuring the large-file ceiling in Cloudflare Artifacts (about 30 MB, 413s, no LFS), catching a durable-object storage choice that would have cost 13x more than R2, and spawning side-quest agents so surfaced tech debt never hijacks the decision thread.

The call that comes out of it: no new data-repo primitive - expand the repo primitive with a package marker, gate large files with a friendly redirect instead of an opaque rewrite, and respect the principle of least surprise as a product principle, not just a programming one.

Homework: before your next "build it," ask your agent for one research deliverable that could change your mind. If it surfaces cleanup, spawn a side quest. Then say go.

Links

How to increase your leverage with agents

Kent C. Dodds — Thu, 06 Aug 2026 12:41:45 -0600

Agents are doing the work you did months ago. That is not doom - it is how abstraction travel works. Kent shows the climb-dont-cling timeline, a conductor-of-orchestrators example, and a one-week homework handoff.

0:00 Cold open: agents take the job / you climb
0:13 Better with Kent intro
0:24 Tweet claim: agents do months-ago you-work
0:51 Uncle Bob / climb layers of abstraction
1:15 History: assembly to modern languages
1:41 Claude Opus 5 / keep innovating
1:56 Screen: drawing the abstraction timeline
3:25 What are you doing now that agents could do?
4:08 Example: theme-park to conductor of orchestrators
7:40 Challenge: let agents do what you are doing
8:06 Screen: visual-recap / system map PR review
9:07 Don't sit still on the timeline - climb
9:50 What's left for me? Higher leverage keeps appearing
10:32 Homework: list 3 / hand off one
11:04 Uncle Bob: be okay walking away from the code
11:31 Close

Better with Kent - durable skills for people who ship software.

The things agents do for Kent today are the things he was doing himself months ago. That pattern is old (assembly to Fortran to frameworks to natural language) and the cadence is faster now.

This episode reframes abstractions as vehicles: climb the timeline instead of clinging to the last layer. Live draw of the abstraction ladder, a theme-park conductor-of-orchestrators story (Cursor Cloud Agents), system-map PR review instead of giant diffs, and homework: list three hand-work items and hand off one this week.

Includes a callout to the Become an Epic Product Engineer conversation with Uncle Bob: be okay walking away from the code.

Links

I Delete Tests Every Night (On Purpose)

Kent C. Dodds — Tue, 04 Aug 2026 11:49:54 -0600

Better with Kent - durable skills for people who ship software.

Every morning Kent wakes up to a PR that deletes more lines than it adds. Not flaky tests. Not broken tests. Low-signal ones — tiny wrappers, magic-number asserts, edge cases that will never happen — the kind AI agents love to generate overnight.

This episode walks the trap (more green checks ≠ more confidence), the bar (fewer, longer tests written into testing-principles.md), a real cleanup PR (kody#603: +122 / −703), and the Cursor Automation that runs Keep Tests Tight at 03:00 MDT.

Homework: run the cleanup once. Give an agent your testing principles and see what it deletes.

Chapters

0:00 — Cold open: I delete tests every night
0:15 — Better with Kent intro
0:33 — Every morning a PR that deletes more than it adds
1:04 — More tests are not better tests
2:03 — Tests are expensive to run / change
2:33 — Agents love tiny tests (magic number 42)
3:33 — Green checks are not confidence
4:33 — Screen: testing-principles.md
5:09 — Fewer, longer tests
7:10 — Screen: kody#603 demo
8:38 — Screen: Keep Tests Tight automation
11:32 — Valuable at the time is not keep forever
11:45 — Homework: run the cleanup once
12:19 — Close: delete some more tests

Links

Forget "read the code," I don't even merge PRs myself

Kent C. Dodds — Thu, 30 Jul 2026 05:46:00 -0600

Your agent opened the PR. Now you're refreshing CI and arguing with bots. Kent shows the ship-pr skill that closes that loop - mark ready, fix CI, triage review, Discord handoff - so you spend attention on risk, not chores.

(00:00) - Still reading the code?
(01:18) - "I read the code" kicked off a war
(01:51) - I do read the code sometimes
(02:31) - You're the PR babysitter
(03:33) - I turned the loop into a skill
(04:14) - Discord handoff is the product
(04:33) - When it won't auto-merge
(05:25) - Inside the ship-pr skill
(06:16) - The ship-pr loop
(06:28) - Merge mode (low risk only)
(07:09) - How far this scales
(07:49) - The factory spectrum
(08:58) - Don't ship blind
(09:43) - 92 times before it was a skill
(10:20) - Homework: ship a PR
(11:03) - Sign-off

Better with Kent - durable skills for people who ship software.

"I read the code" kicked off a war. Kent's take: it's a spectrum based on risk. The afternoon killer is not reading - it's babysitting CI, Bugbot, and "please fix that" loops after the agent already implemented the feature.

This episode is the concrete payoff after loop-engineering: real Discord handoffs from Kody (including a medium-risk PR that stayed unmerged on purpose), the ship-pr skill file, merge mode for genuinely low-risk changes, and the 92-times lesson before formalizing a skill.

Homework: tighten your ship loop. On a simple change, let the agent merge and verify - if your team is good with that.

Links

Stop Reviewing Diffs. Start Reviewing Systems.

Kent C. Dodds — Tue, 28 Jul 2026 07:57:03 -0600

Agent PRs are too big to read line by line. Kent shows a visual system recap in the PR description - classify what changed as composes, extends, or adds - so you review the architecture first, then the code that matters.

(00:00) - Still reviewing git diffs?
(00:25) - Spectrum: not every line, not zero review
(00:43) - Review the system, not just the diff
(00:51) - Steve's visual recap (Builder.io)
(01:17) - Why I rolled my own
(02:30) - System recap + PR #662 (adds)
(05:08) - PR #686 (composes — low risk)
(05:54) - Primitives playground callback
(06:57) - Install kcd-skills visual-recap
(07:35) - Homework + close

Better with Kent - durable skills for people who ship software.

Coding agents ship more code faster, and the review surface explodes. Some people say you have to read every line. Others say never look at the diff. The real answer is a spectrum - and the durable skill is reviewing how the system is changing, not only the syntax.

Kent walks through a visual recap approach inspired by Steve at Builder.io, then shows his own kcd-skills version that needs no account, no deploy, and no inference token. The agent that worked the PR writes a system recap block; GitHub renders the mermaid. Live demos: PR #662 adding an MCP client-servers primitive (high risk) vs PR #686 composing onboarding (low risk). Same domain, different review questions.

Homework: map your primitives, run visual recap on your next non-trivial PR, and decide whether you are reviewing an add, an extend, or a compose before you open the diff.

Links

My Agent Ships Across 6 Services Without Seeing a Secret

Kent C. Dodds — Thu, 23 Jul 2026 07:45:00 -0600

Want the system from this episode? Check out Kody at https://heykody.dev/

Kent replays a real publish night — one Cursor conversation where the agent drove Notion, Canva, Kit, Transistor, Bluesky, and LinkedIn through Kody packages, with every secret kept out of the agent's reach.

(00:00) - Stop copy-pasting between your agent and your services
(01:25) - What we're learning today
(01:49) - The real publish-night conversation
(02:52) - Search: how the agent discovers capabilities
(04:12) - The Notion pipeline board
(04:42) - Execute: conversation id and memory context
(05:50) - Agent-written code without exposing secrets
(08:25) - Kody packages: a registry for your agent
(09:43) - Token-efficient queries in a dynamic worker
(11:53) - No package? Use the OpenAPI spec (Canva)
(14:24) - Interruptions: publish date and square artwork
(17:04) - Default square designs for every episode
(18:15) - YouTube is live: Kit early-access broadcast
(19:37) - Launch posts on LinkedIn and Bluesky
(20:48) - I use this for everything
(22:22) - Homework: wire your services once

Better with Kent — durable skills for people who ship software.

If you're still copy-pasting context between services and your agent, you're missing the real unlock: wiring those services in once so the agent can compose them. Kent walks through an actual episode publish night, one Cursor conversation at a time — search to discover capabilities, execute to run agent-written code in a fast isolated worker, saved packages instead of raw fetch calls, and OpenAPI bindings when no package exists yet.

Along the way: how Kody's memory context and conversation id keep token usage down, how secret templates make it impossible for the agent to ever see a bearer token, mid-task interruptions the agent absorbs without losing the thread, and the Kit, Transistor, Bluesky, and LinkedIn steps that end with a published episode.

Links

Fable nailed my production YOLO infra migration

Kent C. Dodds — Tue, 21 Jul 2026 08:15:00 -0600

One orchestrator prompt, six platform swaps, and a real production cutover on kentcdodds.com — the workflow, the review loop, the perf scare, and where the agents were wrong.

(00:00) - One prompt, 40,000 lines
(00:44) - The site and why migrate
(06:38) - PR #813 — 483 files
(07:09) - Kickoff prompt anatomy
(11:35) - Orchestrate with subagents
(16:13) - Steering + scope expansion
(21:33) - Three-layer review
(23:22) - Kody closes the loop
(25:24) - The performance scare
(30:22) - Merge and cutover
(33:51) - Cleanup waves
(37:44) - Was 40k lines worth it?
(39:40) - Homework: try orchestration

Kent walks through how AI agents moved kentcdodds.com from fly.io to Cloudflare Workers — database, ORM, images, email, MDX pipeline, and more — from a single orchestrator prompt plus steering, subagent swarms, three-layer review, and Kody closing every loop. Includes the performance scare that almost killed the migration, the post-cutover cleanup waves, and an honest rollup of four agent-driven PRs (about 40,000 lines changed).

Links

Your Coding Agent Needs Better Primitives

Kent C. Dodds — Wed, 15 Jul 2026 08:51:00 -0600

If your coding agent keeps producing garbage, better prompting may not fix it. Kent shows how intentional system primitives make agents more reliable, efficient, composable, and auditable.

(00:00) - Bad agent output starts in the system
(00:37) - We are all tech leads now
(01:28) - What is a primitive?
(04:57) - Four moves: create, combine, delete, expand
(06:01) - Create: role-based access control
(07:59) - Combine: downshift and Kody packages
(10:37) - Delete: Instagram and Kody email
(12:22) - Expand: packages subscribe to events
(13:51) - Why good primitives work
(14:43) - Homework for your agent
(15:32) - Keep evolving the system

Better with Kent — durable skills for people who ship software.

If your coding agent keeps producing garbage, the model may not be the problem. Agents are only as effective as the system they work in: the UI components, APIs, data entities, platform tools, workflows, and trust boundaries they can reliably use.

Kent explains four moves for improving that system: create missing primitives, combine overlapping ones, delete rigid or unused ones, and expand the primitives that should cover more. The examples come from real product work — Kody's role-based access control and event subscriptions, PayPal's three combobox implementations becoming downshift, and Instagram winning by deleting most of Burbn.

The payoff is a smaller action space with less guessing, fewer brittle workarounds, and behavior you can actually audit. The episode closes with homework you can run in your own codebase today: ask your agent which primitives you should create, combine, delete, or expand.

Links

The Framework wars are over. Why no one dethroned React

Kent C. Dodds — Thu, 09 Jul 2026 09:08:17 -0600

Kent reacts to Dax's question on X — why no framework dethroned React — and connects it to Jobs Theory, network effects, and why framework choice matters less when agents write the code.

Chapters

00:00 — Why did nobody dethrone React?
00:24 — Dax's question on X
00:49 — React is the last UI library (2020)
02:47 — Functional first, then social and emotional
03:36 — What made React functionally better
06:43 — Network effects and "nobody got fired for choosing React"
07:38 — Why framework choice matters less with agents
09:27 — Jobs Theory: apply this to everything you ship
11:14 — Wrap-up

Better with Kent — durable skills for people who ship software.

Every few years the internet declares the framework wars over — usually with React as the loser. Svelte was going to win. Then Solid. Vue had its moment. Angular never left. And somehow, after a decade of "React is dead" takes, React is still the default for an absurd amount of real product work.

Kent's take: React won functionally first (state sync, composition, drop-in UI focus), then socially and emotionally once it hit critical mass. Challengers can still be "better" on paper — but once agents can use any capable stack, the throne fight stops mattering the way it used to.

Links

What the devil is a Factory Engineer?!

Kent C. Dodds — Tue, 07 Jul 2026 08:51:06 -0600

Kent reacts to Zach Lloyd's Warp memo on "factory engineers" — where the software-factory vision is right, where it misses product context, and why factory work still comes back to users.

Better with Kent — durable skills for people who ship software.

Warp CEO Zach Lloyd told his team they are now factory engineers, not product engineers. Kent reads the memo aloud and pressure-tests the framing: automated development, cloud software factories, agent workflows, and the metrics that can game you if you forget what users are paying for.

He agrees with a lot of the direction — build the system agents work in, measure throughput, tighten the loop — but pushes back on anything that treats the product as optional. Internal tools still have users. Factory efficiency only matters when the right work goes in. And yes, the memo's last word is still product.

If you're trying to make sense of agentic engineering without losing product judgment, this is the durable-skills read-through.

Links

I got attacked! - How I used my AI agent to fight back!

Kent C. Dodds — Thu, 02 Jul 2026 13:54:04 -0600

Kent walks through a real bot/crawler flood against kentcdodds.com, how agentic tooling helped diagnose and mitigate the outage, and what he changed so anonymous traffic is cheaper next time.

Better with Kent — durable skills for people who ship software.

Kent got a Sentry alert that kentcdodds.com was down. A bot or crawler flood had pushed his single Fly.io machine past its request limit, and the expensive parts of his dynamic blog pages made anonymous traffic hit harder than it should have.

This episode walks through the incident response: asking a Cursor agent to investigate with repo context, Kody, Fly CLI access, Cloudflare context, and Grafana evidence; restarting and scaling the machine; blocking junk routes before they hit the origin; and identifying a DigitalOcean host driving a scripted high-concurrency crawl flood.

The durable lesson is not "let AI run production." It is that agents become useful during incidents when they have the right context, observability, tools, and boundaries. The same agent that can read code can also connect symptoms to logs, infrastructure, and follow-up fixes.

Links

I built my own OpenClaw

Kent C. Dodds — Tue, 30 Jun 2026 09:00:00 -0600

Kent shows how Kody gives the coding agent he already uses search, execute, and saved packages so exploratory workflows can become durable personal automation.

(00:00) - Kody handled the demo
(00:41) - Why personal agents have not stuck
(02:21) - Search and execute
(04:31) - Kitchen glare walkthrough
(06:47) - Turning one action into a package
(08:48) - Scheduling deterministic workflows
(10:24) - What I use Kody for today
(13:25) - Connectors, capabilities, and packages
(15:04) - Code Mode and MCP
(16:59) - Augmenting existing software
(18:24) - Integrations, OAuth, and secrets
(20:53) - What should Kody become?

Better with Kent — durable skills for people who ship software.

Kent walks through Kody, the thin runtime layer that lets the coding agent he already uses discover capabilities, execute sandboxed code, and save useful workflows as packages. Instead of maintaining a separate personal assistant brain, Kody gives Cursor, Codex, Claude Code, and similar agents a way to connect to personal APIs, home automation, jobs, integrations, secrets, and reusable package exports.

The episode uses an office-chaos cold open and a kitchen glare walkthrough to show the progression from one-off prompt, to executable code, to saved package, to scheduled workflow.

Links

Pragmatic Loop Engineering for AI Coding Agents

Kent C. Dodds — Tue, 23 Jun 2026 13:45:47 -0600

Kent shows how he closes agentic loops in real Cursor workflows: manual testing, PR review loops, Cursor Automations, and the stop conditions that keep humans in the right place.

(00:00) - Loop engineering before the name
(00:11) - Boris on loops
(00:33) - Better with Kent
(01:01) - What the loop is
(02:59) - Tests were already a loop
(03:24) - Browser mode and manual testing
(05:35) - Human-driven PR looping
(06:43) - My first real loop
(08:37) - Boundaries and stop conditions
(09:37) - Cursor Automations
(11:29) - Trading compute for attention
(12:24) - Homework
(12:52) - Closing

Better with Kent — durable skills for people who ship software.

Loop engineering sounds new, but Kent has been building toward it through a series of practical workflow improvements: automated test loops, Cursor browser mode, Cursor Cloud Agent manual testing, pull request feedback loops, and finally Cursor Automations.

This episode walks through what a useful agentic loop actually needs: a trigger, an act/observe cycle, a stop condition, and a human boundary. Kent shows how he uses agents to mark PRs ready for review, respond to AI reviewer feedback and CI failures, and ping him when the loop has reached its stop condition.

The key idea is not removing the human. It is widening the loop so more verification happens before your attention is required.

Links

Stop Taking Tickets, Start Applying Jobs Theory

Kent C. Dodds — Tue, 16 Jun 2026 12:25:00 -0600

Kent walks Clay Christensen's jobs-to-be-done lens on a food-delivery shared-cart ticket — three questions that turn a solution into a job statement, plus Wayne Allan's Australia flop and Aaron D. Francis on deciphering feature requests.

(00:00) - Your backlog is full of solutions
(01:27) - Jobs to Be Done
(03:12) - Shared cart ticket
(04:04) - When it goes wrong — Wayne
(06:01) - Three questions before you estimate
(06:40) - Question 1 — progress and circumstance
(08:56) - Question 2 — what they hire today
(10:09) - Question 3 — what would fired look like
(11:22) - Aaron on solutions vs jobs
(12:54) - The job statement
(13:47) - Stack with Kano
(14:40) - Big hire vs little hire
(17:19) - The habit — what job is this for?
(19:27) - Homework
(20:12) - Books and close

Better with Kent — durable skills for people who ship software.

Your backlog is full of proposed solutions. Kent walks a shared cart / group ordering ticket (same food-delivery app as the Kano episode) through Clay Christensen's Jobs to Be Done framework — why the expensive mistake is building the wrong thing, not bad code.

Three beats land early: a ticket is not a job, hire/fire/progress language, and the habit "What job is this for?" before the estimate, PRD, or agent prompt.

When it goes wrong — Wayne Allan (*Become an Epic Product Engineer*) on building for every person in Australia logging in at once: ~1.2M AUD, zero users.

Three questions before you estimate: progress and circumstance, what they hire today (group text, separate orders, Venmo as workaround), and what "fired" looks like.

Aaron D. Francis on what users actually want vs the button they asked for.

The job statement: *When our team orders lunch together, help us coordinate food and check out once — without a 40-message thread.*

After you ship: little hire vs big hire, why metrics alone miss the emotional job, and stacking qualitative signal. Homework: one sentence — what is the job to be done?

Links

How an AI Agent Deleted PocketOS Production in 9 Seconds

Kent C. Dodds — Fri, 12 Jun 2026 08:18:00 -0600

When an AI coding agent guessed its way through bad permissions and deleted months of PocketOS production data in nine seconds — and what durable skills would have stopped it.

(00:00) - Cold open — car rental
(01:49) - Today's story
(10:29) - Railway recovery
(14:57) - Three questions
(16:29) - Close

Better with Kent — durable skills through story.

Episode 3 is a cautionary tale: on April 24, 2026, a Cursor agent working on PocketOS staging found a forgotten Railway API token, guessed it could delete a staging volume safely, and wiped production in nine seconds — along with volume-level backups in the same blast radius. Jer Crane and his co-founders spent days reconstructing customer records while Railway worked recovery.

Kent walks the full chain: least privilege, independent tested backups, hard approval boundaries for destructive ops, and why markdown guardrails are not system boundaries. The principles are old; agents just find the holes faster.

Creative license for pacing; primary sources linked below. Based on Jer Crane's public account of the PocketOS incident.

Links

How to Prioritize Software Tasks

Kent C. Dodds — Wed, 03 Jun 2026 02:28:13 -0600

Kent walks the Kano model on a real food-delivery backlog: Must-be, Performance, and Delighter — why GPS was a wow in 2015 and a basic today, and why you cannot delight your way out of broken basics.

Chapters

0:00 The backlog fight
1:39 What type of feature is this?
2:15 Basics (Must-be)
3:47 Performance needs
5:38 Delighters
6:32 GPS lifecycle reveal
7:56 Why silence misleads teams
10:00 Cannot delight out of broken basics
10:36 AI and the junk drawer
11:52 Prioritized build order
14:25 Homework and close

Better with Kent — Durable skills for people who ship software.

You have five backlog items and everyone wants their feature first. Kent uses a food delivery app example and the Kano model (Must-be, Performance, Delighter) to show what type each feature is — and what to build first.

Land three beats: broken confirmation email is a Must-be (fix before anything else), estimated delivery accuracy is Performance (more accurate = more satisfied), surprise discounts and group ordering are Delighters (fun to build, dangerous when basics are broken). The GPS reveal: tracking felt like magic in 2015; today missing GPS means users leave.

Why teams get this wrong: silence in support is not proof basics work — most users leave without filing tickets. You cannot delight yourself out of broken basics. AI makes it worse when agents churn exciting Delighters while hygiene features rot.

Homework: label five real backlog items, fix broken basics first, ask whether last year's Delighter became today's Must-be.

Become an Epic Product Engineer guests cited: Wayne Allan, Sean Roberts, Swizec Teller, Don Norman, Dillon Mulroy, Dax Raad.

Links

Watch on YouTube

What Software Engineers Need in 2026

Kent C. Dodds — Fri, 29 May 2026 13:21:56 -0600

Kent maps the durable skills that stay valuable as agents take more implementation: clarity, judgment, empathy, feedback loops, systems thinking, agent fluency, and ownership — with practical homework for each cluster.

(00:00) - Intro: Google stat and durable skills
(00:20) - Why now
(01:08) - Durable skills map
(01:25) - Clarity & judgment
(03:40) - Wayne Allan: build the right thing first
(04:28) - Practice: clarity & judgment
(06:01) - User empathy & feedback
(07:29) - Practice: empathy & feedback
(08:56) - Systems thinking
(12:22) - InfoWorld: AI coders need good engineers
(18:52) - Agent fluency
(20:14) - Practice: agent fluency
(21:26) - Ownership
(23:03) - Slow down on purpose
(27:05) - What to deprioritize
(28:04) - Homework

Better with Kent — Durable skills for people who ship software.

Episode 1 is the map. Agents can implement faster every month; the expensive mistake is building the wrong thing even faster. Kent walks through seven skills that were valuable decades ago and still matter in 2026: problem clarity, domain depth, judgment, empathy, feedback loops, systems thinking (including closing the agent loop), agent fluency, and ownership.

Three clusters pair each skill area with concrete practice — stakeholder rooms, wiring daily feedback, building tests and CI so agents can iterate. Kent cites Become an Epic Product Engineer guests (Wayne Allan, Jack Ryan, Aaron Francis, Dillon Mulroy, Swizec Teller, Ruben Casas, and others), reacts to Matt Asay's InfoWorld piece on AI-generated code, and closes with homework you can do this week.

Not a tool demo. Not a PM course. Not a framework checklist — just durable skills for people who ship software.

Subscribe and comment with topics you want covered. Chats with Kent (Become an Epic Product Engineer) continues with guest interviews; Better with Kent is Kent thinking out loud on camera.

Links

Introducing Better with Kent

Kent C. Dodds — Fri, 22 May 2026 14:07:49 -0600

AI is accelerating change for software engineers. Kent introduces Better with Kent — solo episodes on durable skills, judgment, and knowing what to build — plus Chats with Kent guest interviews on Become an Epic Product Engineer.

Better with Kent — Durable skills for people who ship software.

The landscape is moving fast. Agents can implement more every month, which means the expensive mistake is building the wrong thing even faster. This series is Kent on camera — no guest — on judgment, accountability, problem clarity, and skills that stay valuable as implementation gets cheaper.

Also continuing: Become an Epic Product Engineer with guests who blend technical depth and product judgment.

Subscribe on YouTube, Spotify, Apple Podcasts, or wherever you listen. Comment with topics you want covered — Kent live-streams many recordings.

Links