● Field Note · TravelogueSan Francisco · May 6–8

Field Note: Code w/ Claude

What changed at Anthropic's developer conference, and what it means for how we build.

Filed byMatthew Hall · Co-founder, Runpoint Partners

Read time12 min · 2,400 words

A year ago this month, Claude Code launched. Runpoint was a month old and we still didn't know how to explain what we do. Last week I spent two days in San Francisco at Code w/ Claude — a developer conference built around hands-on workshops and direct conversations with the Applied AI and technical staff. Heavy hitters. Boris Cherny, who built Claude Code, headlined. The night before, I was at OpenAI's Friends & Family Night with a friend on staff there.

What hit me wasn't the scale, though there were hundreds of people in the room. It was that Anthropic isn't just shipping a model anymore. Obviously they're still in the model war — and winning a lot of it. But they're clearly thinking past it. Models will plateau. Ecosystem, platform, and network effects are what carry the next era. What they put on the table this week was that next layer: Code, Desktop, Cowork, Design, Managed Agents, and the partner ecosystem behind all of it. The foundation for a discipline that didn't have a name eighteen months ago.

That discipline is what we do.

Here's what I took away that's actually changing how we work.

What was in the folio

The kit.

A snapshot of the contents of my Code w/ Claude folio at the end of day one.

1Code w/ Claude badge.

2Runpoint business card.

3OpenAI Friends & Family pass from the night before.

4M5 Cardputer. Pocket-sized keyboard + screen.

5MAFFEW trading card.

The Code w/ Claude folio, opened, with badge, business card, F&F pass, Cardputer, and MAFFEW trading card

12345

§ 01 — ArchitectureThe brain left the box.

The biggest architectural shift I saw is also the easiest to miss. Most agent setups today run the loop inside your container. The agent thinks, acts, and thinks again, all in a sandbox you spun up. When the session ends, the sandbox dies.

Managed Agents move the loop to Anthropic's side. The sandbox is called on demand. You can close your laptop and the agent keeps working. (Anthropic's own framing is "decoupling the brain from the body.")

That sounds like a deployment detail. It isn't. It changes what's possible:

Multi-hour runs without minding them.
True statefulness across browser closes.
No cold-start tax per session.
The agent stops being "a script you run" and becomes "a worker you have."

For mid-market clients, this is the difference between an automation that runs when someone clicks a button and a colleague that's actually on the team. We're redesigning two engagements around it.

Credit where it's due: OpenClaw, Clawd, and Hermes were pushing on this idea before Anthropic shipped it as a hosted product. The novelty isn't that the loop runs somewhere durable — that's been working in our setup for months. It's that moving the loop out of the active session is now a first-class option you can buy. That's a real shift in how we think about agent work.

The Code w/ Claude main stage, with Boris Cherny presenting alongside a wood-paneled set and pink boucle armchairs — Prometheus himself, Boris Cherny, discussing innovations in fire.

§ 02 — SubstrateMemory stores, and what dreaming is for.

The second pattern Anthropic is pushing hard: persistent memory stores that agents read from and write to across sessions.

The mechanic is simple. Two sessions. Same memory store attached. Session A learns something. Session B knows it. The store is inspectable, editable, version-controlled, and attributable — Claude wrote this, the user wrote that.

The interesting part is what they layered on top. A batch process called Dreaming reads transcripts plus the existing store and produces a consolidated store. Architecturally: one orchestrator spawns parallel sub-agents, one per transcript. They read each other's writes, dedupe, distill. The output is a candidate store you compare against the live one before promoting. Clone, don't replace.

Memory stores capture during the moment. Dreaming reorganizes after the fact.

— Workshop notes · Day 1, afternoon session

Different update cadences over the same foundation. Live capture and batch consolidation. That framing is useful for almost any AI system question we're sitting with right now.

§ 03 — MethodThe life-changing magic of decluttering your agent.

The best workshop of the day was, on paper, a "decomposition framework." In practice it was Marie Kondo for agent setups. AI configs drift. Every reasonable addition leaves a residue. Six months in, you're staring at a 400-line system prompt and a pile of typed tools that nobody fully remembers, and the thing performs worse than it did at week three. Anthropic's reference example was exactly that.

Starting state: 12 tools, 3 hardcoded subagents, a 402-line system prompt. Every individual decision had been reasonable when it was made. The aggregate was the problem.

Ending state: 15 lines of system prompt. 400 lines of skills loaded on demand. Zero hardcoded subagents — delegation became a runtime decision. Eval score moved from 71% to 92%. A daily task that took 488 seconds and 102 tool calls now took about 100 seconds and 3 scripts.

Eval score

71 → 92%

+21 pts on the same suite

Wall time

488 → 100s

~5× faster

Tool calls

102 → 3

scripts, not RPCs

Prompt

402 → 15

lines of system prompt

Tool, skill, or subagent?

Definition

Smell test

Tool

One function. Stateless, deterministic, returns small output.

Returns >2k tokens? Use code execution over a file instead.

Skill

Instructions loaded on demand when relevant.

Writing "always do X before Y" in the prompt? That's a skill.

Subagent

A separate agent with its own context and goal.

Output is a single number? It shouldn't be a subagent.

Counterintuitive move from the same workshop: going from 12 typed tools to one Bash tool with file access. The instinct as an engineer is to make tools more typed, not less. The lesson is that for read-mostly, large-output operations, giving the agent a sandbox with files plus Bash is faster, cheaper, and more accurate than carefully designed JSON contracts.

Most of the agents we see in the wild are six months in and look like a junk drawer. This framework is how you tidy up — keep what sparks joy, throw out what's secretly dragging the whole thing down.

§ 04 — BusinessThe reframe.

The throughline across the day, the part I'm still chewing on:

A year ago the client question was "can you build us an agent?" That's still a real question. But the workshops were quietly pointing somewhere else.

The pattern: per-person agents and sessions, tied to a team-wide memory store. The individual instances are cheap and disposable. The shared layer is the asset. What gets remembered, what gets distilled, what gets governed.

The new question

It might not be "build a client an agent." It might be: stand up the plumbing. The connectors, the shared memory, the governance, the patterns. Then make it easy for the team to build their own agents on top.

That's a different business. Closer to platform thinking than project thinking. And it lines up with what we've been telling clients anyway. The win is operator capability, not vendor lock-in.

MAFFEW — an 8-bit trading card from Code w/ Claude with stats: Wisdom 82, Charm 91, Strength 78, Style 85

A small detour

They made trading cards for everyone.

Somewhere in the swag pile is an 8-bit MAFFEW. Wisdom 82. Charm 91. Strength 78. Style 85. Stats my wife will dispute.

It's the kind of thing that's easy to read as cute, but it isn't. It's a tell about who Anthropic thinks they're building with. Not the IT buyer. Not the procurement officer. The operator-engineer who would actually keep this on their desk for a year.

§ 05 — OutputWhat we're doing about it.

Three changes already in motion at Runpoint.

Two engagements, redesigned around Managed Agents.

Server-side loops change the unit of work. We're updating the SOWs. Agents that close the laptop with you and keep going.

New workshop: Build your team's second brain.

Forked from Anthropic's memory-store workshop, run with the client's own data. Take-home value, not a demo. We'll pilot internally first.

The Decomposition Audit.

Most clients with existing agents are sitting on a 400-line prompt and a pile of typed tools. The audit produces a measurable, defensible path to the after picture.

One last thing

Most ecosystem events are cringey or soulless. This wasn't either.

I've been to a lot of corporate ecosystem days. Dreamforce. SXSW parties. The content was usually a placeholder for the open bar.

Code w/ Claude wasn't either. The content was substantive. The Anthropic team was engaged and accessible. The workshops were teaching artifacts as much as the lessons inside them.

Hat tip to Anthropic for the day, and to the team that put it together. Whatever this discipline ends up being called — we're all in.

Matthew Hall is a founding partner of Runpoint, the SaaS replacement firm. We replace the software mid-market companies rent with systems they own, and put AI to work inside them. Get in touch →