How building software is changing at Anthropic

The Pragmatic Engineer · email · 2026-07-28 Reader 🖥️

theoretical · mixed — Journalistic reporting built from four on-the-record Anthropic interviews plus two extended case narratives (Claude Managed Agents, the Bun rewrite), used as evidence for a broader descriptive claim about where software-engineering practice is heading inside a leading AI lab. Expository/narrative in method, but the selection and framing serve an implicit argument — verification, not implementation, is now the bottleneck — more than a neutral survey.

Structure

Key terms

• Claude Managed Agents Long-Running & Managed Agents
  Anthropic's pre-built harness product for production agents, runnable on Anthropic-managed cloud infrastructure, a customer's own infrastructure, or with any sandbox the customer chooses — an interface decoupling the agent 'brain,' the sandbox 'hands,' and the event-log 'session.'
• Spiking
  Building a minimal, working end-to-end version of a system for a single real internal customer first (here: Claude Code's mobile backend), before generalizing the architecture for external customers — used to stress-test the design against real constraints rather than speculative ones.
• Fanning out
  Jarred Sumner's term for distributing many independent chunks of work to many parallel Claude agent instances at once, with an orchestrator agent collecting suggestions and making the actual commits, rather than working with one agent sequentially.
• Tokenmaxxing Token Throughput
  Gaming or inflating token-usage metrics that a token budget or leaderboard would otherwise incentivize; named here only to say Anthropic doesn't have this problem because there is no token budget or usage tracking to game.

Propositions

• explicitBuilding Claude Managed Agents (a pre-built cloud- or self-hosted harness for production agents) took Anthropic's Claude Platform team about six months — a project Katelyn Lesse says would probably have taken about two years pre-AI.conf: high
  extendsBuilding AI Agents For The Enterprise · p19 — Supplies the origin story, internal build cost, and ~6-month timeline behind the Claude Managed Agents product that the other extraction credits as a strategically central part of Anthropic's enterprise substrate.
• explicitPlanning, not prototyping or implementation, was the single largest and most important phase of the Claude Managed Agents project, closely resembling a typical pre-AI planning process.conf: high
• explicitPRDs, authored and coordinated as shared Google Docs, remain necessary for complex, cross-team projects even inside an AI-native organization, because they align humans and business stakeholders, not agents.conf: high
• explicitInternal cross-team alignment on interfaces is now faster and more fluid than pre-AI: teams stand up rough stub components or services and iterate live with a client team, rather than exchanging fully-specified requirements documents up front.conf: high
• explicitcontestedA large, mature production codebase (Bun, 535,496 lines of Zig) can be rewritten to a different language (Rust) in about 11 days by one domain expert directing 64 parallel AI agents for $165,000 in API-price tokens — a migration that, done by hand, would have needed a small team of engineers roughly a year while freezing bugfixes, security fixes, and features.conf: high
  extends ←Bun Rewrites 535K Lines of Zig into Rust in Four Months, Eliminates Numerous Memory Leaks · p1 — Gives the fuller end-to-end timeline (4 months to the v1.4.0 release) against the companion piece's 11-day initial-rewrite-sprint framing, showing most elapsed time went to post-hoc hardening rather than generation.
  contradicts ←Andrew Kelley Interview: Why He Built Zig, Banned AI Contributions, and Moved Zig off GitHub · p7 — That piece frames the AI-agent-assisted Bun-to-Rust rewrite as a capability/technical achievement; Kelley explicitly disputes reading it as a technical or language-merit verdict at all, attributing it instead to diverging project values.
• explicitA mechanical, behavior-preserving rewrite — minimal semantic changes, validated against the project's existing (language-independent) test suite — is a safer strategy than an open-ended reimplementation when migrating a large codebase to a new language.conf: high
• explicitIn the Bun rewrite, actual code-generation/implementation was roughly 15% of total effort; the remaining ~85% went to fixing compile errors, tests, and verifying the result worked as expected.conf: high
  supportsMeasuring AI impact, assessing readiness, and new data trends · p1 — The Bun rewrite's own time breakdown (15% implementation / 85% fixing and verifying) is a concrete internal data point for the claim that code generation was never the real bottleneck.
• explicitThe 11-day rewrite depended on Jarred being the codebase's original creator and best-informed expert; the article states this as a precondition without addressing whether the same speed and safety would hold for a team attempting a comparable rewrite without an equivalent domain expert directing it.conf: medium
• explicitdevelopedRunning multiple (3-10+) AI coding agents in parallel per person, with no token budget or usage tracking to promote 'tokenmaxxing,' is now normal working practice at Anthropic, and comes with very high individual autonomy relative to Big Tech or most startups.conf: high
  extends ←How Claude Code Is Built · p11 — The earlier 'multi-clauding' data point (25% of Max users run parallel agents, reported as an open question) is the precursor observation that the later article generalizes into 'running 3-10+ parallel agents per person is now normal working practice.'
• explicit⚡ disputed & corroboratedBecause engineers can no longer personally read all the AI-generated code now being merged at high volume, trust in that code must instead come from layered automated, out-of-process verification — AI code review, a dedicated security scanner, and fuzz testing — rather than from a human reading every diff.conf: high
  extendsAgentic Code Review · p2 — Jarred's '100+ PRs a day, trust without reading it all' problem is the concrete, practitioner-side confirmation that the precondition making human code review scale (reading faster than writing) has broken down.
  contradicts ←Bun Rewrites 535K Lines of Zig into Rust in Four Months, Eliminates Numerous Memory Leaks · p8 — The companion piece frames layered automated verification (AI review, security scanner, fuzzing) as a legitimate substitute for human line-by-line review at scale; Kelley's critique here directly disputes that this substitution is trustworthy, on the same underlying rewrite.
  supports ←How Claude Code Is Built · p8 — Orosz's earlier reporting (Sep 2025) that Claude does first-pass code/security review with a mandatory human second pass is the concrete layered-review pattern that the later 'building software' piece (Jul 2026) generalizes into a broader claim about trust in AI-generated code coming from layered automated review.
• explicitManual merge-button-pressing by a human is expected to give way, within a few months, to automatic merging once a second, fresh-context-window AI reviewer judges a change simple and low blast-radius, at least for the Bun project.conf: high
  extendsAgentic Code Review · p12 — Gives a concrete two-step mechanism (automated reviewer LGTM, then a second AI's fresh-context blast-radius judgment before auto-merge) for the abstract 'human moves from reading every diff to owning judgment and high-blast-radius gates' pattern.
• explicit"Fanning out" — dispatching many independent chunks of work to multiple parallel AI agents at once rather than to one agent sequentially — is a pattern Jarred finds underused beyond one-off large rewrites.conf: high
  extendsClaude Code: Best practices for agentic coding · p16 — Jarred's interactive fan-out of a single hard migration across many parallel Claude agents is the same 'fanning out' pattern as Claude Code's headless-mode batch fan-out across CI pipelines, applied to a much less mechanical, higher-judgment task.
• explicitcorroboratedAssumptions embedded in agent and product design must be re-tested at every new model generation because capability jumps can silently invalidate them — Anthropic deleted 80% of the Claude Code system prompt for this reason.conf: high
  supports ←How Claude Code Is Built · p5 — The team's concrete practice of deleting scaffolding code (e.g. half the system prompt) whenever a new model release subsumes it is a specific instance of the later article's broader claim that design assumptions must be re-tested at every new model generation.
• explicitHTML is now a better default output format for AI agents than Markdown for some uses at Anthropic, because current Claude models handle HTML competently and it conveys richer, more shareable structure — reversing an earlier assumption that agents should default to Markdown.conf: high
• explicitMost tokens spent in AI-assisted development at Anthropic are no longer spent on implementation, but on discovery of unknowns, prototyping, mocking, and verification/testing.conf: high
  supportsAssumptions as code: SiriusXM's approach to platform prioritization · p7 — Thariq's observation that most tokens go to discovery and verification, not implementation, is a direct practitioner confirmation of the claim that cheap code generation shifts the bottleneck to discovery and review.
• explicitAt the team level, design has become more of an ongoing activity and less front-loaded, people work across more concurrent projects, and Anthropic caps most projects at a maximum of two engineers.conf: low
• explicitDespite the changes above, two-pizza teams, the importance of planning, the relevance of PRDs on complex projects, the challenge of context switching, and a roughly stable ratio of coding-to-testing time have all persisted unchanged from before the AI wave.conf: low
• explicitThe 'standout' software engineer archetype at Anthropic is shifting toward deep understanding — including of the layer below what one directly works on — plus the ability to coordinate work.conf: low
• explicitThe more hands-on Anthropic's software engineers get with AI, the less they report fearing that AI will replace their jobs.conf: low
• explicitClaude Managed Agents keeps credentials out of the agent, sandbox, and session entirely: all calls needing credentials go through a proxy holding a session token, the proxy alone fetches the actual secret from a vault, and it is injected only at the egress boundary when the service is invoked.conf: high
  extendsAnthropic Details How It Contains Claude Across Web, Code, and Cowork · p11 — Same underlying egress-containment idiom reported from two angles: Claude Managed Agents' vault-and-proxy design injects credentials only at the egress boundary so the agent/sandbox/session never see them, while the InfoQ piece reports Anthropic reaching the same session-token-scoped-proxy pattern for Cowork only after a domain-allowlist bypass (api.anthropic.com's Files API) showed that trusting a destination is not the same as trusting every function reachable through it. Read together, the CMA architecture is the pattern built proactively; the Cowork fix is the same pattern arrived at reactively, after an incident — corroborating that egress-boundary credential injection is Anthropic's converged design, not a one-off.

Arguments

Narratives

• Before generalizing Claude Managed Agents for external customers, the Claude Platform team first built and shipped a narrower, real service for an internal customer (spinning up sandboxes and booting Claude Code for the mobile app), then re-architected around a 'brain' (agent) / 'hands' (sandboxes and tools) / 'session' (event log) split once that internal build surfaced hard problems — reliability when sandbox connections drop, and credential/access-control handling.
  → Supports the proposition that internal-customer-first, dogfooded prototyping surfaces integration problems earlier and more concretely than designing the generic/external-facing version up front.
• Jarred Sumner's 11-day rewrite of Bun from Zig to Rust — 64 parallel agents, $165,000 in tokens, an orchestrator agent that alone made commits from other agents' suggestions to avoid conflicts, and Bun's own pre-existing, language-independent (TypeScript) test suite serving as the pass/fail oracle — is offered as proof of what became technically and economically feasible for one domain expert, where a full year of frozen feature/bugfix work would have been organizationally unacceptable for a small human team.
  → Illustrates the argument that verification (not implementation) is the real bottleneck, and that a pre-existing, trustworthy test suite is what makes a large AI-driven rewrite safe to attempt at all.
• In Claude Managed Agents' credential architecture, all calls that need credentials go through a proxy holding a session token; the proxy alone fetches the actual credentials from a vault, and they are injected only at the egress boundary when the service is invoked — the agent, sandbox, and session itself never see them.
  → Shows a concrete security pattern (deterministic credential injection at the egress boundary, never inside the agent's own context) for keeping a powerful, autonomous agent from ever directly handling secrets it could leak or misuse.

Questions addressed

• ✅ How do you let customers build production AI agents on infrastructure they trust (self-hosted or Anthropic-hosted) without every customer re-inventing 'harness infrastructure' from scratch?
  Claude Managed Agents: a brain/hands/session-decoupled architecture plus a vault-and-proxy credential model, arrived at via internal dogfooding before generalizing.
• ✅ Can a large, mature codebase be rewritten to a safer language without an unacceptable freeze on bugfixes, security fixes, and features?
  Yes, for Bun specifically: a mechanical, minimal-behavioral-change rewrite validated against the existing test suite, executed via 64 parallel AI agents directed by the original codebase's creator, in 11 days.
• ✅ How do you establish trust in code you personally can no longer read at the rate it is produced and merged?
  Layer automated, out-of-process verification (AI code review, a dedicated security scanner, fuzz testing) in place of exhaustive human reading, moving toward auto-merge gated by a second AI's judgment.
• ⭕ Do the practices described (unlimited tokens, an original-creator-level domain expert directing the rewrite, an internal-lab audience willing to dogfood a new service) generalize to teams without Anthropic's token economics, bench depth, or internal customer base?

Gaps

• incompleteSections 4-7 of the article (team-level changes, what's stayed the same, the changing 'standout' engineer archetype, and the 'will AI replace software engineering' argument) are paywalled; only the author's own one-line table-of-contents previews are visible, not the supporting reporting, quotes, or argument.
  Read next: Obtain the full subscriber article, particularly the 'will AI replace software engineering?' section — squarely inside the persona's rigorous-adopter interest in whether hands-on AI experience reduces or increases fear of job loss — and the 'standout engineer' section, relevant to the persona's craft/leadership interests.
• uninformedThe reporting draws entirely on four named individuals inside Anthropic (a platform-org engineering head, one high-profile external contractor turned employee, one cross-functional engineer, one applied-AI/sales-engineering role) with no comparison to Anthropic teams operating under tighter constraints, no former-employee or outside-critical perspective, and no acknowledgment that access journalism inside the very lab that sells the tools being praised may select for best-case, showcase-ready stories.
  Read next: Look for outside-in or critical accounts of Anthropic engineering culture (former-employee retrospectives, competitor comparisons, or the promised follow-up piece comparing Anthropic and OpenAI) to check whether practices like the 11-day Bun rewrite are typical internally or a cherry-picked outlier.
• incompleteThe $165,000-in-tokens figure for the Bun rewrite is given 'at API price' but the article doesn't address whether this reflects Anthropic-employee internal/discounted token access versus what an external customer attempting the same feat would actually pay, nor how it compares to the counterfactual cost of continuing to hand-maintain Zig memory-safety bugs indefinitely.
  Read next: The article itself links to a companion piece, 'What can we learn from Bun's rapid Rust rewrite with AI?', which reportedly covers this in more depth — worth reading for the cost-accounting the free preview lacks.
• illogicalThe piece treats 'all tests pass' as sufficient proof that the Bun rewrite 'works,' but doesn't examine whether the pre-existing TypeScript test suite has coverage adequate to catch subtle behavioral divergences a full cross-language rewrite could introduce — the same test suite being reused as the oracle for the very change that could invalidate its assumptions.
  Read next: Cross-read with material on test-suite adequacy and mutation testing, or with the article's own companion piece on the Bun rewrite, to see whether post-rewrite defect rates in production are reported anywhere.
  closed byBun Rewrites 535K Lines of Zig into Rust in Four Months, Eliminates Numerous Memory Leaks — Reports the empirical outcome the companion piece left unexamined: post-merge fuzzing, 11 rounds of security review, and further validation caught 19 subtle semantic regressions the original TypeScript test suite had not caught, and fuzzing surfaced 15 more PRs' worth of issues — direct evidence that 'all tests pass' was not sufficient proof of correctness and that additional out-of-band verification layers did real, non-redundant work.

Related documents

• Anthropic Details How It Contains Claude Across Web, Code, and Cowork
• Building AI Agents For The Enterprise
• Claude Code: Best practices for agentic coding
• Agentic Code Review
• Assumptions as code: SiriusXM's approach to platform prioritization
• Measuring AI impact, assessing readiness, and new data trends
• Agentic AI and Code Reviews
  Multi-Agent Orchestration Pull Requests & Async Code Review Trust
• Harness design for long-running application development
  Long-Running & Managed Agents Multi-Agent Orchestration Riding Model Improvements
• Anthropic's Designs Three-Agent Harness Supports Long-Running Full-Stack AI Development
  Long-Running & Managed Agents Multi-Agent Orchestration Riding Model Improvements
• AWS Expands DevOps Agent with AI-Powered Release Management to Validate Code Before Production
  Agentic Testing Pull Requests & Async Code Review Verifiability (as the Quality Bar)