Better with Kent

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

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

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://10xn.link/kcd-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

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

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

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

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

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

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

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