CHAPTERS
From a quiet launch to “armies of agents”
Boris and Cat look back on the modest initial launch of Claude Code and contrast it with how they work now—often orchestrating many agents in parallel. A core habit emerges: when the model makes a mistake, they encode the fix into durable guidance (Claude.md) or reusable skills so the system improves over time.
Verification isn’t just tests: making agents actually run the thing
They redefine “verification” for agentic coding: it’s not only unit tests or linting, but ensuring the agent can execute and validate the feature in the real environment. Boris describes the early “wow” moment of Claude building a feature and testing it via CLI, which later became routine across simulators and desktop setups.
Skills + real-world debugging loops (desktop app, staging, Slack)
Cat shares how a “desktop development skill” teaches Claude to run and interact with the local desktop app using computer-use. When environment issues arise (e.g., staging instability), Claude is directed to check Slack for known incidents and then update the skill after diagnosing the issue, reinforcing a self-improving verification loop.
Roles are merging: designers, PMs, finance, and DS in Claude Code
They discuss how Claude Code expands beyond engineers as adjacent roles adopt it after seeing its leverage. Within Anthropic and across enterprises, designers prototype directly in-product, PMs ship changes, finance runs projections, and data scientists use Claude Code as a daily driver—signaling broader role convergence.
Routines as the breakthrough: always-on CI, triage, and proactive fixes
Routines emerge as a pivotal application of programmatic Claude Code usage, turning agents into background operators for operational tasks. Cat describes routines that monitor GitHub issues and bug reports, generate fixes, and surface PRs—sometimes resolving problems before the original author even sees them.
Boris’ default workflow: auto mode replaces plan mode
Boris explains why he now prefers auto mode over plan mode: newer models often don’t need an explicit planning artifact. Auto mode enables asynchronous work—start Claude, let it run, move to the next task/agent—without babysitting each step.
Making auto mode safe: permission routing, red teaming, and evals
They argue auto mode can be safer than manual approvals because humans habituate to approving repetitive prompts. Safety is achieved through routing suspicious actions to security checks, extensive red teaming, and building evals from thousands of real trajectories to ensure advanced attacks are denied.
Engineering intuition breaks: building on models requires relearning
Boris reflects on how often initial skepticism about model-driven approaches (like auto mode) proved wrong. Working with rapidly improving models forces teams to discard some traditional engineering assumptions and rely more on empirical iteration.
Loop as the next leap: from “talk to an agent” to “talk to a system”
Loop represents a second major transition: first engineers stopped editing code directly and instead instructed agents; next they stop even prompting agents manually and rely on loops/routines to manage prompting and execution. This changes the primary interface from code → agent → orchestration layer.
How orgs change when AI is central (the “computerization” analogy)
Boris compares AI adoption to the shift from paper processes to computers: productivity gains required putting computers at the center, not bolting them on. At Anthropic, Claude becomes the default hub—onboarding questions, coding, reviews, security checks, and operational tasks flow through it, accelerating organizational transformation.
Product vs engineering is dissolving: end-to-end ownership becomes standard
They argue the future isn’t product or engineering—it’s both. Engineers increasingly ship end-to-end including coordination with legal/marketing/security, while PM/Design/DevRel write code; the winners are curious builders with product taste who can drive outcomes across the stack.
Operating hundreds of agents: agent view, desktop app, voice, and Remote Control
Boris describes the tooling shift needed to manage many simultaneous agents: agent view reduces tab chaos, the desktop app simplifies worktree management, and Remote Control plus voice mode enable starting and supervising work from a phone—making “coding from the couch” viable.
From context engineering to context minimalism
They note the evolution from prompt engineering to context engineering, and now toward minimalism with stronger models. The recommended approach is to provide minimal system prompts and tools, then ensure the model can pull context as needed—avoiding micromanagement that can reduce performance and flexibility.
What’s next: longer autonomy, new form factors, and community-driven discovery
They close by predicting rapid change: agents will run longer, become more autonomous, and operate in large swarms, requiring new interfaces beyond today’s workflows. Boris and Cat emphasize that future breakthroughs will come from continuous team experimentation and from the broader community building alongside them.
