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

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

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

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

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

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

• Watch on YouTube
• Kody
• Kody on GitHub
• The chat walkthrough from this episode
• Your Coding Agent Needs Better Primitives (the episode being published)
• Better with Kent

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

• PR #813 — migration
• Slides deck
• kentcdodds.com

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

• Better with Kent
• Kody
• downshift
• I built my own OpenClaw