Skip to content
Artwork for Better with Kent
TechnologyEducationSelf-Improvement

Better with Kent

Kent C. Dodds

Solo episodes from Kent C. Dodds on durable skills for people who ship software: judgment, accountability, problem clarity, and what stays valuable as AI takes on more implementation. Kent teaches directly on camera — no guest, one idea at a time. Complements guest interviews on Become a Product Engineer (Chats with Kent). Episode 1 adapts The Last Software Engineer; later episodes cover traps like building the wrong thing faster and skills like making user pain visible. Subscribe for evergreen episodes as the series grows.

Play
  • 33 episodes
  • weekly
  • Avg 16 min
  • English
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • #32
    Tuesday · 9 min

    What I Changed to Beat a Million-Install AI Skill

    Matt Pocock's triage skill has been installed over a million times. I moved the repeatable parts into deterministic software, kept the judgment in the skill, and it got faster, cheaper, and more accurate in every mode. Here's how to build that hybrid. (00:00) - A million-install skill, made better (00:26) - Every skill has the same problem (00:47) - From manual process to software (02:08) - Turning the triage skill into software (04:07) - Devin's benchmark: Lite, Normal, Ultra (04:46) - Most of the skill doesn't need a model (05:24) - Faster, cheaper, more accurate (05:59) - The hybrid skill (06:21) - Taking it further with Kody (06:46) - My ship-pr skill: one command on repeat (07:46) - A cheap decision model (08:26) - Waiting and merging safely (09:24) - Just-in-time context Better with Kent - durable skills for people who ship software. Thank you to Sentry for sponsoring this episode: https://kcd.link/sentry Skills are awesome. You hand a manual process to an agent and it just handles it. But agents are slow and expensive, and they're perfectly happy to spend all your tokens on work that should have been software. We used to turn processes we understood into software. With skills, we stopped doing that. So I took Matt Pocock's triage skill and had Devin benchmark it against a hybrid version: gathering, paginating, sorting, applying, and verifying moved into a deterministic script, and only the judgment stayed with the model. The hybrid was faster in every mode (Lite, Normal, and Ultra), cost the same or less, and was more accurate every time. Then I show how I take it further with Kody (shared credentials, reusable code, and triggers) using my ship-pr skill: one tiny command on repeat, software handling the process, a cheap decision model for the small calls, and the expensive coding agent saving its effort for real judgment. What are your agents doing that should be software? Tell me in the comments. Links Sentry (sponsor) Matt Pocock's skills Kody Better with Kent

    • Transcript
    • Chapters
  • #31
    November 10 · 15 min

    Build What They Can't

    Big companies can copy your features in an afternoon. Here's how to put your product in a safe harbor they won't follow you into: trust, incentives, community, proprietary data, audience, domain depth, and the right niche. (00:00) - Big players keep shipping my features (00:32) - Sherlocked: Watson and Raycast (01:18) - Lesson one: find a safe harbor (01:33) - 1Password: the trust safe harbor (04:35) - Kody: what the labs won't build (06:49) - Dropbox: a feature, not a product (08:34) - Community: Raycast's extensions (10:02) - Proprietary data: Waze (11:36) - Audience: Nathan Barry and Kit (12:05) - Domain depth: Abridge (13:14) - Niches too small for giants (13:57) - Safe harbor or empty harbor? (15:17) - Watch out for invisible software Better with Kent - durable skills for people who ship software. Thank you to Sentry for sponsoring this episode: https://kcd.link/sentry Every day I open X and see another big player ship a feature I already have. If your product is just a pretty UI on top of a spreadsheet, you're in trouble. But giving up isn't the only option. The better move is to pivot into a safe harbor where the big guys will never go, and make yourself untouchable by design. I start with Watson, the app that gave us the word "Sherlocked," then walk through the safe harbors that have kept products alive next to giants: trust (1Password), incentives (Dropbox, and what I'm doing with Kody), community (Raycast), proprietary data (Waze), audience (Nathan Barry and Kit), deep domain expertise (Abridge), and niches too small for a giant to bother with. Then there's the boring version of untouchable: sometimes the giants leave you alone because nobody wants what you built. I share the test I use to tell a safe harbor from an empty one. Where is your product anchored? Tell me in the comments. Links Sentry (sponsor) Kody How I'd Get Into Software in 2026 The Future of Software is Invisible Better with Kent

    • Transcript
    • Chapters
  • #30
    November 3 · 14 min

    How I'd Get Into Software in 2026

    If I were starting from scratch in software engineering today, here are the two skills I'd work on right now (systems design and communicating intent), how I'd practice them, and the durable skill that stays valuable no matter how good agents get. (00:00) - Is coding over? (00:28) - Skill 1: understand and design systems (01:26) - Skill 2: communicate intent (03:16) - I can't promise these skills will last (05:30) - The adjacent possible (06:04) - The printing press and the iPhone (06:52) - Nobody planned DoorDash (07:30) - Git, GitHub, and agents as our printing press (08:07) - Antifragile (08:51) - No skill makes you antifragile (09:30) - Get close to real problems (10:35) - Skin in the game and trust (11:40) - Don't chase every shiny thing (12:20) - The durable skill (12:53) - What I'd do if I started today (14:00) - Terminator or Star Trek, this still works Better with Kent - durable skills for people who ship software. Thank you to WarpBuild for sponsoring this episode: https://kcd.link/warpbuild A lot of people are scared. Is it over? Are we just moving on from coding? Frankly, yes, coding is over. But I don't think that means we can just give up. If I were getting into software engineering today, I'd work on two skills right now. First, understanding and designing systems: what the pieces are, what each one is responsible for, and how they talk to each other. I'd practice by sketching out the apps I already use with an agent. Second, communicating intent: the what and the why, the constraints, and a way for the agent to verify its work, so it doesn't fill the gaps with guesses. But I can't promise those skills will still matter in three or six months. So the back half is about the skill that does: noticing the adjacent possible. That's Stuart Kauffman's idea (I learned it from Steven Johnson's Where Good Ideas Come From). The printing press, the iPhone, and Git all opened doors nobody planned for. Agents are our printing press, and the doors are flying open. Then I pair it with Nassim Nicholas Taleb's antifragile. No skill is going to make you antifragile. What does is getting close to real problems felt by real people, owning outcomes (skin in the game), building trust, and being intentional about which shiny things you chase. What would you do if you were starting from scratch today? Tell me in the comments. Links WarpBuild (sponsor) Where Good Ideas Come From by Steven Johnson Stuart Kauffman (the adjacent possible) Antifragile by Nassim Nicholas Taleb Better with Kent

    • Transcript
    • Chapters
  • #29
    October 27 · 10 min

    My AI Employees Won't Let Me Sleep

    I gave my AI agents everything they need to work without me, and now they never sleep, never eat, and never run out of questions for me. Here's what that's costing me (sleep, meals, and time with my kids) and the quiet hours fix I built for my Grok Bots on camera. (00:00) - They never sleep (00:23) - I removed every reason to wait on me (01:00) - My huge mistake: the software factory (01:56) - I turned into a boss of agents (02:57) - The only limit left is me (04:45) - What happened at the theme park (05:24) - No sleep, no lunch, no exercise (06:44) - "I'm going to sleep" (then 3 more messages) (06:59) - Holding myself accountable (07:39) - What's on my plate (08:41) - The fix: quiet hours for my agents (10:05) - How do you make yourself stop? Better with Kent - durable skills for people who ship software. Thank you to PowerSync for sponsoring this episode: https://kcd.link/powersync I can get a month's worth of work done by answering a couple of questions before bed. Cloud agents keep running with my laptop closed, I check on them from my phone, and Kody gives them the connections to get context and take action on their own. All that's left for me is the decision making. That sounds amazing until you realize the questions never end. A boss knows they can't text their employees at 2 in the morning and expect an answer. My agents don't have that limit. They answer in seconds, every time. So the only limit left is me. In this episode I get honest about what that's costing me: sending messages to my agents while I was in line at a theme park with my kids, skipping meals, skipping workouts, and telling an agent "I'm going to sleep" at 1:17 in the morning, then sending it three more messages within 92 seconds. Willpower is clearly not going to fix this. So I built quiet hours for my Grok Bots, right on camera. From 10 PM to 8 AM they keep working, but they only interrupt me for something truly urgent (like production being down), and I get one summary in the morning. If you've got agents that never sleep, how do you make yourself stop? Tell me in the comments. Links PowerSync (sponsor) How to Put Your Codebase on Autopilot How to Increase Your Leverage with Agents (the theme park video) Kody MEGA (mega.dev) Better with Kent

    • Transcript
    • Chapters
  • #28
    October 20 · 14 min

    The Future of Software is Invisible

    SaaS products are in serious trouble, and it's not because someone vibe coded Adobe in Rust. We're heading toward a world where billions of people create software without even realizing it, because their agents write it for them. I call it invisible software. Is your product ready for that? (00:00) - SaaS is in serious trouble (00:24) - Nobody wants to be a coder (00:40) - Agents are outgrowing the benchmarks (01:18) - Billions of people's agents (03:31) - Victoria's agent builds her an app (04:58) - Max forks it with a Book now button (06:55) - Victoria pulls in Max's change (08:17) - Walled gardens (and why I built Kody) (09:53) - Seven Adobe apps vibe coded in Rust (11:03) - Software engineering isn't going anywhere (11:54) - Make your software agent ready (12:34) - Is your site agent ready? (13:11) - Is your app ready for the next billion users? Better with Kent - durable skills for people who ship software. Thank you to Warp Build for sponsoring this episode: https://kcd.link/warpbuild People don't want apps. They want their problems solved. Agents get better every month (we're running out of benchmarks hard enough to measure them), so more and more of those problems will be solved by software an agent writes on the spot. Not millions of developers writing code by hand at the speed of humans, but billions of people whose agents write, commit, and push code at the speed of AI. I call this invisible software. In this episode I walk through a demo with two barbers, Victoria and Max. A proactive agent builds Victoria a custom client app wired up to her Stripe and iMessage. Max forks it for his Square store and adds a Book now button. Victoria pulls his change back into her version. Then Max tries to switch agents and runs straight into a walled garden (which is a big part of why I'm building Kody). Software engineering isn't going anywhere. Banks, airlines, and infrastructure still need teams who own their systems. But how you solve problems for your users is going to change shape. If your product isn't easy for agents to use, your users' agents will go to your competitors. So, is your app ready for the next billion users? Links Warp Build (sponsor) Kody Invisible software demo ArtCraft: 7 Adobe apps vibe coded in Rust Reverse Engineer Anything Epoch AI Benchmarking Hub METR time horizons Is It Agent Ready? (Cloudflare) is-agentic (Vercel) Better with Kent

    • Transcript
    • Chapters
  • #27
    October 13 · 19 min

    How to Put Your Codebase on Autopilot

    I shipped 122 PRs in 24 hours straight out of my software factory, mostly while I was doing something else. Here's the system that lets agents file their own friction, make good PRs, catch their own mistakes, and keep the blast radius small. Here's what 122 PRs in one day looks like: https://github.com/kentcdodds/kody/releases/tag/v2026.10.11 (00:00) - 122 PRs in 24 hours (00:17) - Agent-filed friction, agent-shipped fix (00:51) - Agents work around friction (01:41) - The ship PR skill files friction (02:43) - Lauren Tan: 2,500 PRs a month (03:43) - Three pillars of confidence (04:19) - Sponsor: Devin (05:35) - Good PRs: decisions directory (06:06) - Primitives catalog (07:11) - control Kody CLI for self-verification (08:24) - System recap on every PR (09:24) - Catch mistakes: the ship PR package (10:00) - AI reviewers: Bugbot, CodeRabbit, Devin (11:07) - Merge, watch deploy, Discord report (12:19) - Limit blast radius: feature flags (13:46) - Disaster recovery (14:33) - Cleanup: agents don't love deleting code (15:28) - Dogfooding and product decisions (16:31) - Pipe signals in: Sentry, errors, feedback (18:00) - Nightly and weekly agents (18:35) - Recap Better with Kent - durable skills for people who ship software. Thank you to Devin (Cognition) for sponsoring this episode: https://kcd.link/cognition Agents don't fix friction. They work around it, and those workarounds compound across every agent touching your codebase. The fix is to turn your agents into complainers: the ship PR skill ends every merge by filing friction, and other agents come through and fix it - sometimes while you sleep. Kent walks the three pillars that make that safe: (1) good PRs in the first place (a decisions directory, a primitives catalog, the control Kody CLI for self-verification, and a system recap on every PR), (2) catch mistakes before prod (the ship PR package, CI, CodeRabbit, Cursor Bugbot, Devin AI review, preview deploys), and (3) limit the blast radius (feature flags with success metrics, disaster recovery with restore tests). Then cleanup, dogfooding, and signal pipelines from Sentry, runtime errors, user feedback, and nightly/weekly agents. Agents handle polish, code quality, and implementation. The product vision stays with you. Links Devin (sponsor) Kody Better with Kent

    • Transcript
    • Chapters
  • #26
    October 6 · 21 min

    Steal My App (I'll Show You How)

    Self-hosting Kody off Cloudflare used to sound thermonuclear. Deno Celld changed the math — and Kent's Grok bot handed the experiment to Devin. Then docker compose up actually worked. (00:00) - Cold open: Kody running in Docker (00:10) - Better with Kent (00:16) - Self-hosted Kody is real — here's the path (00:58) - Ask: self-host Kody off Cloudflare (01:10) - Clarify: Kody, not Jev (01:42) - Thermonuclear — tied to Cloudflare (02:02) - Own Cloudflare account is fine under OSS (02:33) - Deno Celld — hard, not thermonuclear (04:23) - Revised difficulty: hard is OK for agents (04:37) - Hand the experiment to Devin via Kody (06:16) - Devin launches on Ultra (06:46) - Prompt, auth gaps, and Kody unsticks Devin (08:15) - Inspect the Celld repo and fill gaps (08:57) - Ship-PR loop until main is green (10:41) - Rebuild the UI to match official Kody (12:38) - Make it tryable: public image + README (14:09) - Follow the README ourselves (14:56) - docker compose up — it works (15:27) - Create account on localhost:8080 (16:33) - Connect Cursor MCP (and fix public URL) (17:45) - Connected — memory + dad-joke package (19:23) - Success: first run without reading the code (20:02) - What's still missing — contribute if you care (20:56) - Homework: self-host or use kody.codes (21:24) - Close Better with Kent - durable skills for people who ship software. Kent asks his Grok bot how hard it is to self-host Kody off Cloudflare. First answer: thermonuclear rewrite. Then Deno Celld (Workers + Durable Objects on your machines, S3-compatible state) revises that to hard — and hard is fine when you hand it to an agent. Kody briefs Devin Cloud to build a Celld-based self-hosted Kody. Auth hiccups, gap fills, ship-PR loops, GHCR image, from-zero smoke. Kent follows the README, docker compose up, creates an account, connects Cursor MCP, saves a memory, and ships a dad-joke package — first run without looking at the code. Homework: if you want self-hosted Kody, contribute. If not, use kody.codes and let hosted handle the edge. Links Kody Better with Kent

    • Transcript
    • Chapters
  • #25
    September 25 · 13 min

    Build a Software Pipeline: Help your agent help you

    Package apps on Kody turn a package into something you can install and use on your phone. This episode walks morning briefing, package-app-kit, and a phone demo of a swipe deck over Gmail, GitHub, and Calendar. Better with Kent - durable skills for people who ship software. Thank you to Devin (Cognition) for sponsoring this episode: https://kcd.link/cognition Kent shows package apps on kody.codes with @kentcdodds/morning-briefing and @kentcdodds/package-app-kit, then cuts to a phone demo of Claude building a Tinder-for-attention swipe deck over real feeds. Homework: pick one package you already trust and ask what it would take to ship it as an installable app surface, not just an MCP tool. Links Kody Better with Kent

    • Transcript
  • #24
    September 15 · 24 min

    Make your agent safe and autonomous

    Gmail has no drafts-only OAuth scope. If an agent can draft, it can send. Two Kody locks make drafts-never-send actually true. (00:00) - Cold open: agent sent email without review (00:52) - Better with Kent (01:25) - PocketOS: overscoped token callback (02:20) - Gmail has no drafts-only scope (02:46) - Two locks: token + package (03:40) - Elephant: your current Gmail plugin (05:47) - Ask the agent / paste the guide (07:17) - Google Cloud OAuth client (13:03) - Connect Google to Kody (15:38) - Smoke-test draft (no send) (16:56) - Save and lock the drafts package (19:16) - Pin the Google token in Integrations (19:47) - Browse the locked package files (20:35) - Verify: execute blocked + promote (22:52) - Close: lock the grant (23:49) - Homework: .env God-tokens Better with Kent - durable skills for people who ship software. Gmail has no drafts-only OAuth scope. gmail.compose can draft and send. If an agent can draft, it can send - unless you put a real grant in front of the token. Kent walks the locked-gmail-drafts path on Kody: smoke-test a draft with the coarse Google token, then save a thin drafts-only package, lock that package so it cannot grow send without a promoted commit, and pin the Google connection so ad hoc execute cannot call it. Two locks. The Google token stays coarse; the pair is the grant Google will not issue. Homework: open your .env, look at the God-tokens your agent can slurp, and put them behind a grant the agent cannot widen. Kody is one way. The skill is the grant, not the product. Guides: https://kody.codes/guides/locked-gmail-drafts and https://kody.codes/guides/google Links Locked Gmail drafts guide Google connect Kody Better with Kent

    • Transcript
    • Chapters
  • #23
    September 8 · 2 min

    Introducing Kody: Your Personal Software Factory

    You already paid an agent to figure it out. Tomorrow you ask again. Kody turns the good answer into a package you keep, so any agent can run it forever. (00:00) - You ask again (00:22) - What if you only had to ask once? (00:43) - A personal software factory (01:05) - Then it keeps running (01:25) - Still running (01:50) - Not another agent (02:06) - Secrets stay in Kody (02:36) - Say it once, run it forever Better with Kent - durable skills for people who ship software. You ask your agent to do something. It figures it out eventually. Tomorrow you ask again. New chat, new agent, new device. You didn't keep it. You just paid for the agent to do it again. What if you only had to ask once? Kody is not another AI agent. You've already got one of those. Probably several. Kody is what the agent reaches for when the work shouldn't disappear when the conversation ends. Your agent figures something out once. Kody saves it as a package: real code you own. Think of it as your own mini GitHub and npm. Then it runs on a schedule, a webhook, a tap on a phone. No model in the loop. Faster, cheaper, safer. And it keeps running in the cloud when your laptop is sleeping or dead. Secrets stay in Kody. The agent stays blind. Packages can lock so an agent cannot go rogue and delete your email. Use the agents you love. The personal software they wrote comes with you to all of them. Say it once. Run it forever. For all the agents you use today and the ones you'll use tomorrow. Give your agents a home for free at https://kody.codes Source is on GitHub. Go give it a star. Related: How Kody Gives Your Agents a Shared Home - https://www.youtube.com/watch?v=h5G8uaZHrVI Links Kody Kody on GitHub How Kody works How Kody Gives Your Agents a Shared Home (ep 22) Better with Kent

    • Transcript
    • Chapters
  • #22
    August 27 · 15 min

    How Kody Gives Your Agents a Shared Home

    You already pay for more than one agent. Give them a shared home so Cursor, Grok, and Devin share software, memories, and tasks instead of starting from zero every chat. (00:00) - Meet Kody (00:22) - Better with Kent (00:46) - How Kody works (01:08) - Cursor asks what the bot shipped (01:40) - Search, conversation ID, memories (03:03) - Execute + secrets stay in Kody (04:35) - Code mode: only the answer comes back (05:45) - Save it as a package (07:23) - Grok reuses the package (09:16) - Devin: tell me when it ships (11:36) - What the agents wrote (13:15) - Any agent can run it (13:52) - Early-access invite (14:28) - Close: give agents a home Better with Kent - durable skills for people who ship software. You probably subscribe to more than one agent. Cursor on the laptop. Grok on a walk. Devin when you want something watched overnight. Each one starts from a blank context window. None of them share the software, memories, or secrets you already built in the last one. Kody is that shared home. Kent walks the How Kody Works page end to end. Cursor does not know the favorite bot, so it searches Kody, picks up memories plus a githubAccessToken secret it never actually sees, and runs the fetch in an isolate. Code mode returns only the answer you asked for, type-checked. Then it saves the work as a package: @u/kodybot what-shipped. Grok reuses that package from a phone with no rewrite. Devin cannot hang a webhook on someone else's GitHub activity, so it adds a morning job and a daily digest email instead. The files look like normal package.json plus kody.jobs, a README intent, and JSDoc the next agent can search. Secrets stay in Kody. Packages can lock a secret so only that package can use it. You can edit a package from a phone with no local git because the agent opens a repo session that simulates git. You do not have to install Kody to take the skill. Agents leapfrog each other. Give them a place to share software, ideas, memories, and tasks so you can switch freely. Early access invite code: YOUTUBE-FRIEND Redeem it at https://kody.codes/signup?utm_source=youtube&utm_medium=video&utm_campaign=bwk-shared-home&utm_content=signup Related (context only): I built my own OpenClaw - https://www.youtube.com/watch?v=TnztlHzhYvk Links Kody Early access signup (code YOUTUBE-FRIEND) How Kody works Kody on GitHub I built my own OpenClaw (ep 06) Better with Kent

    • Transcript
    • Chapters
  • #21
    August 25 · 12 min

    Turn your agent on auto-pilot with ADRs

    New agent chats keep asking product questions you already answered. Write short ADRs so the next agent opens the no instead of making you the memory. (00:00) - Fill the agent's mind (00:36) - Better with Kent (00:46) - The problem: decisions die in chat (02:06) - The solution is ADRs (03:06) - Epic Stack + Remix origin (03:32) - Template + AGENTS.md pointer (04:21) - What to write ADRs about (05:22) - Cameron - 0001 + 0006 (06:59) - Darren - wait on skills / 0015 (07:54) - One-off hooks - 0021 (08:50) - Persistent services - the missing no (11:13) - Don't write diaries or an ADR per PR (11:45) - Homework - three declined decisions (12:33) - Close Better with Kent - durable skills for people who ship software. Every new agent conversation starts from zero. Last week's product decision lives in a chat nobody will reopen. You become the memory. That does not scale. The old fix still works: architecture decision records. An ADR is a short record of a decision already made. Context, decision, consequences, and a revisit-if. Put them in docs/decisions/. Point AGENTS.md at the folder so the agent checks before it proposes a new primitive or surface. They are not set in stone. They give the next agent a starting place so it does not re-decide, re-ask, or plow into a direction you already refused. Kent walks real Kody receipts. Cameron's call became 0001 (no package versioning) and 0006 (no repo CI primitive). Darren's call became 0015 (wait on skills over MCP). A late-night one-off hooks idea became 0021: talk first, stay in packages. Then the missing no: persistent services kept getting defended because there was no written decision. After the back-and-forth, the primitive was deleted in kody#1552 and 0025 was written. Write the no before the next agent. Do not write essays nobody opens, UI diaries, or an ADR on every PR. Ten seconds on the trap, then homework. Homework: create docs/decisions/ this week. Write three declined decisions you already made. Link the folder from AGENTS.md. Agents will start asking whether the thing you just discussed should be an ADR. Links Episode slides ADR template (sample) Nygard: Documenting Architecture Decisions Kody AGENTS.md Kody decision records Kody ADR template 0001: no package versioning 0006: no repo CI primitive 0015: wait on skills over MCP 0021: publish-gated package composition 0025: no package services primitive kody#1552 (removed package services) Better with Kent

    • Transcript
    • Chapters
  • #20
    August 20 · 24 min

    Here's how the new MCP spec works

    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 MCP 2026-07-28 release post MCP 2026-07-28 changelog Cloudflare: the next generation of MCP CIMD (client.dev) Kody dual-lane MCP PR Episode slides Better with Kent

    • Transcript
    • Chapters
  • #19
    August 18 · 8 min

    The craft "dying" is your OPPORTUNITY

    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 Use AI to make product decisions (previous episode) Better with Kent

    • Transcript
    • Chapters
  • #17
    August 13 · 20 min

    Stop Burning Your Context Cash

    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 When to useMemo and useCallback The new rules of context engineering (Claude blog) Evaluating AGENTS.md (ETH Zurich / arXiv) Episode slides Better with Kent

    • Transcript
    • Chapters
  • #18
    August 11 · 23 min

    Use AI to make product decisions

    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 Cloudflare: Your agent needs a computer, not a container The Cursor cloud agent conversation from this episode Human factors, product debt, and industrial design with Will King Episode slides Better with Kent

    • Transcript
    • Chapters
  • #16
    August 6 · 12 min

    How to increase your leverage with agents

    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 Source tweet Episode slides Architecture, AI agents, and product empathy with Robert C. Martin Stop Reviewing Diffs. Start Reviewing Systems. kcd-skills / visual-recap Better with Kent

    • Transcript
  • #14
    August 4 · 12 min

    I Delete Tests Every Night (On Purpose)

    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 kody testing-principles.md kody#603 — trim low-signal community suites Keep Tests Tight automation Better with Kent

    • Transcript
    • Chapters
  • #13
    July 30 · 11 min

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

    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 Watch on YouTube kcd-skills / ship-pr kody#709 - medium-risk handoff (no auto-merge) kody#628 - bots + merge by kody-bot Mitchell Hashimoto - "I read the code" Kent's reply on the spectrum I Was Doing Loop Engineering Before It Had a Name Better with Kent

    • Transcript
    • Chapters
  • #12
    July 28 · 8 min

    Stop Reviewing Diffs. Start Reviewing Systems.

    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 kcd-skills / visual-recap PR #662 - adds mcp-client-servers PR #686 - composes onboarding Slides deck Design Primitives Agents Can Actually Use Better with Kent

    • Transcript
    • Chapters
Showing 1–20 of 33 episodes