Better with Kent

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

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

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

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

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?

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

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

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

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

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?

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?

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

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