CHAPTERS
- 0:00 – 1:12
From quiet launch to “armies of agents”: how Claude Code evolved in a year
Boris and Cat reflect on the humble beginnings of Claude Code and how quickly it transformed from a novelty into a daily driver. They describe today’s workflow as multi-agent, hierarchical, and driven by capturing learnings into durable instructions and skills.
- •Early launch had minimal internal attention, but users found it promising for small tasks
- •Current workflow involves many parallel agents, even agents prompting other agents
- •Key habit: when Claude makes a mistake, encode the fix into Claude.md or a reusable skill
- •Goal is compounding reliability so the system can “run forever” with fewer repeated corrections
- 1:12 – 2:24
Verification redefined: beyond tests and lint to “can the agent actually run it?”
They reframe verification for agentic coding as operational reality: the agent must be able to execute the product, not just pass static checks. The chapter highlights the mental shift required to design verifiable agent workflows and the early surprise of models testing their own work.
- •Verification for agents isn’t just unit tests/type checks—those were already automated
- •Core question: can the agent run the thing end-to-end in the real environment?
- •Example: Claude building a feature and then testing itself via CLI/bash felt like a breakthrough
- •Loops now exist for iOS/Android simulators and desktop environments, making self-testing normal
- 2:24 – 3:13
Skills that make verification real: desktop dev skill, computer use, and Slack-aware debugging
Cat explains how the team encodes practical environment knowledge into a “desktop development skill” so Claude can run and test the desktop app. When staging or environment issues arise, the agent cross-checks Slack signals, debugs, and then updates the skill so the fix persists.
- •A dedicated desktop dev skill teaches Claude how to run the local desktop app
- •Claude uses computer-use to click through UI flows, including new UX and edge cases
- •When staging bugs happen, Claude reads Slack to determine whether infra is down or known
- •After debugging, they update the skill so future runs incorporate the new knowledge
- 3:13 – 4:47
Roles are merging: engineers, PMs, designers—and even finance—work inside Claude Code
The conversation broadens to how Claude Code changes who can safely ship changes. As code generation becomes easier, product taste and context matter more, enabling non-engineers to contribute directly through Claude-assisted coding.
- •Boris notes surprise at designers submitting PRs, then normalizing it as quality improves
- •As Claude writes more of the code, the human contribution shifts toward ideas and context
- •Enterprises see adoption spread from engineers to adjacent roles who “look over the shoulder”
- •Designers prototype in-app, PMs make changes directly, and finance even runs projections in Claude Code
- 4:47 – 6:01
Routines as the breakthrough application: proactive bug-fixing and always-on maintenance
Cat describes “routines” that continuously listen for issues and trigger fixes without manual prompting. These routines can auto-triage feedback, open PRs, and even resolve bugs before the original author sees the report.
- •A routine monitors tickets/issues/bug reports for voice mode and proactively proposes fixes
- •A separate routine targets unresponded bug reports after a time threshold (e.g., 5 hours)
- •Developers increasingly discover “another Claude already fixed this” via background automation
- •Routines make the Agent SDK feel concretely useful by providing an obvious, repeatable pattern
- 6:01 – 6:40
Routines for CI and code review: the end of babysitting PRs
Boris explains how routines evolved from a vague programmatic idea into a practical system that continuously handles the drudgery of engineering. The result is less time on CI failures, rebases, and comment chasing—and more time on higher-level work.
- •Agent SDK was powerful but initially unclear in how to apply broadly
- •Routines became the first “obvious” application that people could operationalize
- •Claude now handles code review, monitors PRs, and resolves routine CI/rebase issues
- •Day-to-day engineering shifts away from reactive maintenance to parallelized progress
- 6:40 – 8:24
Auto mode replaces plan mode: asynchronous work without watching every step
Boris shares his shift from plan mode to auto mode as models improved and needed less explicit planning. Auto mode enables him to start work, walk away, and move on to other agents—without reading endless permission prompts.
- •Plan mode mattered more for earlier model generations; newer models need it less
- •Auto mode enables “start and move on,” supporting multi-agent parallel workflows
- •Permission prompts were the early safety mechanism, but they create attention fatigue
- •Routing tool decisions to a security-checking model can be safer than humans rubber-stamping prompts
- 8:24 – 10:26
Securing auto mode: threat modeling, red teaming, transcripts, and evals
They detail how the team built trust in auto mode through extensive adversarial testing and evaluation. The approach combines real usage transcripts, deliberate prompt injection attempts, and continuous improvements to deny unsafe actions.
- •Security requires real threat modeling—not just theory—because attacks are non-obvious
- •They collected thousands of agent trajectories and permission prompts to train/classify safety
- •External and internal red teamers attempted prompt injection and repo hacking scenarios
- •Attacks were turned into evals to ensure auto mode consistently denies unsafe actions
- 10:26 – 11:07
“Loop” as the next leap: from talking to an agent to talking to systems that prompt for you
Boris frames loop as the next interface evolution: humans move from writing code, to talking to agents, to orchestrating loops/routines that manage prompting automatically. This marks a second major shift in a short time, emphasizing higher-level intent over direct interaction.
- •First leap: engineers stopped interacting primarily with source code and started directing agents
- •Next leap: engineers stop talking to a single agent and instead rely on loops/routines
- •Loops effectively automate prompting strategies and iterative work without constant supervision
- •The pace of interface evolution has been surprisingly fast—two big shifts in ~18 months
- 11:07 – 13:20
Engineering orgs with Claude at the center: the “throw out the filing cabinet” analogy
Boris compares AI adoption to the PC revolution: productivity gains arrive only when workflows are redesigned around the new tool. He argues the best organizations put Claude at the center of onboarding, knowledge access, reviews, and routine operations.
- •Historical analogy: PCs increased productivity only after business processes were rebuilt around them
- •AI similarly requires restructuring workflows, not bolting a model onto old processes
- •At Anthropic, onboarding and daily Q&A route through Claude rather than people
- •Claude becomes central for coding, code review, security review, and operational tasks (e.g., forms)
- 13:20 – 14:12
Product vs engineering is a false choice: end-to-end ownership becomes the default
They argue the future blends PM and engineering responsibilities as AI lowers implementation barriers. The most effective contributors combine curiosity, product taste, and full-stack ownership—from idea to ship to comms and safety.
- •Cat: “Everyone’s gonna be both”—roles converge across product, DevRel, design, and engineering
- •Engineers increasingly ship end-to-end, coordinating with legal/marketing and security
- •AI rewards curiosity and product sense, not just implementation speed
- •Ownership expands from coding tasks to full lifecycle delivery and accountability
- 14:12 – 16:04
Working with hundreds of agents: agent view, desktop app workflows, voice mode, and Remote Control
Boris explains how his personal workflow changed from many local checkouts to a streamlined, multi-agent control plane. New interfaces like agent view and Remote Control enable him to start and manage work anywhere—often from his phone using voice mode.
- •Old workflow: multiple terminal tabs with separate git checkouts; new workflow: one tab plus agent view
- •Desktop app automates worktree cloning, reducing manual environment management
- •Remote Control enables starting work on a computer and managing agents from a phone while away
- •Voice mode supports spawning agents in-the-moment during conversations without returning to a desk
- 16:04 – 17:14
From context engineering to context minimalism: give less, let the model pull what it needs
They describe a shift away from heavy prompt/context engineering toward minimal, enabling instructions. The goal is to provide just enough structure and tools for the model to retrieve context itself, avoiding micromanagement and preserving room for user intent.
- •Past eras required more prompt engineering (Sonnet 3.5) and context engineering (Opus 4)
- •Today’s models work better with minimal system prompts and minimal toolsets
- •Key requirement: give the model a mechanism to pull in needed context on demand
- •Too much context can reduce performance by constraining the model’s problem-solving flexibility
- 17:14 – 18:07
What’s next: longer-running autonomy, new form factors, and product ideas from the whole team/community
Boris predicts the dominant workflows will change again as agents run longer and scale to hundreds or thousands concurrently. He emphasizes that future breakthroughs will come from continuous user contact and a culture where everyone can propose and build product ideas.
- •Trends: more autonomy, longer-running agents, and multi-agent as the default
- •Form factors must evolve to manage dozens/hundreds/thousands of concurrent agents effectively
- •The team structure—everyone ideates, talks to users, and can build—drives discovery
- •Innovation will come not just from the core team but from the broader community building alongside them
