Code with Claude 2026 — all 19 talks, summarized
Anthropic published 8 hours and 23 minutes of talks from their Code with Claude developer conference in San Francisco. Most of it is worth watching, but almost nobody has a full working day to spend on conference video.
So I pulled the transcript of every one of the 19 talks and compressed each into a few sentences — what it's actually about, and the one thing worth taking away. Direct video links throughout, so you can jump straight to the ones that matter to you and skip the rest.
Five things nearly every speaker said, independently
- The bottleneck moved off writing code. It's now verification, review, security and taste. Dario Amodei framed it as Amdahl's law: speed one thing up and whatever you didn't speed up becomes the constraint.
- Delete your scaffolding. Retry loops, tool routers, RAG, chunking, screenshot coordinate math — all absorbed into the models. Removing code now often raises performance.
- Verification is what unlocks autonomy. Bun's bot can't open a pull request without a test that fails before the change and passes after. That single rule is what makes running hundreds of agents overnight safe.
- Expect to re-architect at every model step-change. Harvey did it three times. The thing to invest in isn't the architecture — it's logging, replay and evals, because those tell you whether the new model actually helped.
- Give the agent a computer. A sandbox, a browser, a CLI, a file system. Cursor, Vercel, Replit and Anthropic all converged on this, and on file-system memory replacing bespoke RAG.
If you only have two hours
- #8 Getting more out of the Claude Platform — prompt caching, context engineering, the advisor pattern. Straight cost savings.
- #5 Building on Claude at GitHub scale — cache-hit-rate engineering and two reusable review patterns.
- #10 The capability curve — cut your prompts, fix your evals, close the loop.
- #4 Live coding with Boris Cherny & Jarred Sumner — what a genuinely closed autonomous loop looks like in a real repository.
All 19 talks
1.Opening Keynote
No new model — a product keynote built on one framing: model capability is on an exponential, but organizations adopt on a linear, and the gap between the two is the whole opportunity. Announcements include doubled Claude Code rate limits, multi-agent orchestration, outcomes (define success and let Claude iterate until a grader passes it), and "dreaming," where agents review past sessions overnight and write what they learned into memory.
Stat worth quoting: Stripe converted 50,000 lines of Scala to Java in four days against a ten-engineer-week estimate; Mercado Libre runs 23,000 engineers on Claude Code.
2.A conversation with Dario & Daniela Amodei
The headline number: Anthropic planned for 10x annual growth and saw roughly 80x annualized in Q1 — which is the real reason behind the compute crunch and rate limits. Dario expects the unit of leverage to move from individual productivity to whole teams and organizations, and renewed his prediction of a one-person billion-dollar company in 2026.
Takeaway: retry things that failed six months ago. Capability jumps light up products that were previously impossible — they built a Claude Code-like tool in 2022 and the models simply weren't good enough yet.
3.What's new in Claude Code
A feature tour in two halves. Developer experience: remote control (start a session on your laptop, continue from your phone), flicker-free full-screen rendering, and a rebuilt desktop GUI. Autonomy: auto mode, where a classifier approves permission prompts unless an action looks destructive or like prompt injection; first-class git worktrees; automatic memory; and routines that fire on a schedule, a webhook or an API call with no human present.
Steal this: a daily routine that triages new GitHub issues and posts a digest to Slack.
4.Live coding session with Boris Cherny and Jarred Sumner
The single most convincing demo of the event. Bun runs a bot that automatically reproduces every incoming GitHub issue and opens a pull request — and it is now a larger contributor to Bun than Jarred himself. The rule that makes it safe: the bot cannot open a PR unless it ships a test that fails on the old build and passes on the new one.
Generalize it: point the same pipeline at customer support tickets instead of GitHub issues, and anything repeatable goes into CLAUDE.md so the next run gets it right first time.
5.Caching, harnesses and advisors: building on Claude at GitHub scale
The most operationally useful talk of the conference. Copilot runs at a 94–96% prompt-cache hit rate and treats 70% as evidence of a bug — the usual culprits are dynamic content in the system prompt and dynamically loaded tools, both of which invalidate everything behind them. They also debunk "long context costs more": a smaller context window tripled their compaction rate, and compaction burns expensive output tokens.
Two patterns: the advisor (cheap model executes, expensive model is consulted only on the hard step) and rubber duck (a cross-model critique after the plan, after a complex implementation, and after writing tests but before running them). Also: measure survival rate of accepted code, not acceptance rate.
6.Getting to production faster with Claude Managed Agents
Framed by research on where developers actually get stuck: one in three struggle with context management, half say infrastructure is their number-one production blocker, and most run agents with no formal observability at all.
Worth stealing even without the product: outcomes — instead of a prompt, give the agent a rubric defining "done," and let a separate grader send it back until it passes. In their demo that loop autonomously took a dashboard from 37 seconds to 10 with no human tuning.
7.Building AI-native: inside the stacks powering Cognition, Gamma and Harvey
The recurring confession: all three companies completely re-architected at every model step-change, and all three say that is simply the cost of doing business. Cognition threw away elaborate custom code-editing technology once models could edit natively, and custom planning and memory systems once models could just use a file system.
The advice that matters: don't over-invest in the agent architecture — it will be scrapped. Invest in logging, observability, replay and evals, because that is what tells you whether a new model made things better. And note Harvey's caution: individual productivity gains spread widely do not equal organizational productivity.
8.Getting more out of the Claude Platform
The most practical talk for anyone paying an API bill, in strict order of operations. First, prompt caching — a 90% discount on input tokens, and cached tokens don't count against rate limits. Second, context engineering: defer-load tool definitions so unused tools never enter context, let the model write code to extract only the few bytes it needs from large tool results, and use compaction as the sledgehammer. Third, the advisor strategy.
Warning he repeats: avoid framework abstractions that hide what's actually in the context. You cannot engineer what you cannot see.
9.How Datadog built a universal machine tool for Claude Code
The most conceptually ambitious talk. Datadog built a Kafka-compatible streaming system with Claude Code in about a week — a comparable system built by hand took them a year — and shadow tests suggest it could be two to five times cheaper than what they run today. The blocker isn't building it; it's the operational mileage a system must earn before anyone other than its author can run it.
Their answer: stop letting each agent session improvise throwaway glue. Have it emit small, precise, human-readable specifications that are repeatable and reusable — the jig-and-fixture move that turned mechanization into industrialization.
10.The capability curve
Where the model gains actually landed: planning (models now think before acting, so give them room), error recovery (the old "doom loop" of retrying a broken fix until context died is largely gone), and attention across very long runs, which means you no longer need to babysit the context window.
Three concrete tips: make your evals match your real traffic rather than an academic benchmark; delete prompt rules you added for older models, because you often gain performance by removing rather than adding; and give the agent a way to inspect its own output so it can verify its work.
11.Architecting for model step-changes: a fireside with Vercel's Guillermo Rauch
Rauch's core move is giving every agent its own sandbox and then removing the scaffolding he'd built around weaker models — when the newer model landed they deleted an entire autofix pipeline that existed only to patch syntax errors. He gave the whole company an unlimited token budget, and the surprise was that people used it to build their own internal tools.
The framing to keep: stop micromanaging agents with pre-mapped error paths and fixed tools. He expects interaction to shift from synchronous to asynchronous — you become a board member who gives an agent resources and a check-in date.
12.Building with Claude Managed Agents and Asana AI teammates
Asana's pitch is "multiplayer" agents: an AI teammate is a real actor in the system with permissions, shared memory and an audit trail, rather than a single-user chatbot you copy and paste out of. You assign it work like a person, several colleagues steer it in comments, and corrections persist so the next person doesn't hit the same mistake.
Worth your time only if you care about enterprise agent permissions and human-in-the-loop approval flows.
13.Running an AI-native engineering org
The best management talk of the set. What breaks when coding stops being the bottleneck: near-zero design docs (ship three prototype PRs and debate the actual diffs), no six-month roadmaps, every manager starts as an individual contributor, and explicit permission to kill old processes — because processes never kill themselves.
Do this on Monday: pick your noisiest recurring meeting or workflow and ask whether it still serves its original purpose.
14.The thinking lever
The clearest available explanation of "effort" as a dial. Same model, same prompt, ten times the tokens produces visibly better work — demonstrated with a traffic simulation that goes from crude to genuinely good as effort increases. Effort beats a thinking on/off toggle because a toggle constrains how the model works, while effort tells it how hard to try.
Rule of thumb: for coding work, use a large model at low effort rather than a small model at high effort when the task needs intelligence but you want speed.
15.Building with Claude on Google Cloud
A live end-to-end build: napkin sketch to wireframe to UI to a Cloud Run, Firestore and BigQuery backend, then a security review and deploy — with Claude Code wearing five different job hats. The Google-specific parts are a live documentation service and deployment skills, so you can ship on GCP without knowing GCP.
Largely a platform demo — skip it unless you deploy on Google Cloud.
16.Evaluating and improving Replit Agent at scale
The best talk on evals. Replit's argument is that SWE-bench-style benchmarks don't fit their users, who write no tests and start from an empty repository — what matters is "does the app do what was asked." They launched an open benchmark built from real product specs and graded by an agent that opens a browser and clicks through a plain-English test plan, plus a system that clusters millions of production traces to find failures that never show up in a dashboard.
Notable finding: models are roughly twice as bad at extending their own generated code as they are at fresh code. Test between features or you're building on sand.
17.Giving coding agents their own computers: how Cursor built cloud agents
Cursor onboards agents the way it onboards people: give them a computer, a working dev environment and documentation. They built an onboarding agent that explores a repository to work out how to run it, and a CLI so agents stop burning time waiting on services.
The best idea in the talk: every agent is instructed to report anything broken, annoying or confusing into a shared system of record, which humans triage and fix — agents improving their own working conditions. Agents also record video demos, so you review the demo before the diff.
18.Memory and dreaming for self-learning agents
Memory modelled as a plain file system the model manages with bash and grep rather than a bespoke memory API, with read-only and read-write scopes, version history and per-agent attribution. The new idea is "dreaming": an out-of-band job that reads recent session transcripts, finds patterns no single agent could see, verifies and de-duplicates memory, and writes back an improved state.
Numbers cited: Rakuten reported a 90% drop in first-pass mistakes; Harvey reported a sixfold increase in task completion on a legal benchmark.
19.The expanding toolkit
The clearest statement of the conference's central theme: the scaffolding you built last year now ships inside the model. Tool routers, retry loops, chunking and RAG, manual cache breakpoints and screenshot rescaling maths have all been absorbed.
The rule to keep: code that compensates for model unreliability has a half-life of months; code that connects the model to your data and tools compounds. Practical wins: describe tool output schemas as well as inputs, and clear stale tool results from context.
How this was made. Nine of the nineteen talks had usable captions. The other ten had none at all, so I downloaded the audio and transcribed roughly four and a half hours of it locally with Whisper, then re-ran three files that came back with transcription loops and checked every transcript for repetition damage before summarizing. Summaries are mine; any errors are mine too.
Notice something wrong, or think I mis-ranked a talk? Tell me.