Anthropic engineering blog

Loading
Using a "chaos loop" to harden the Claude Docs launch: 60 server errors across billions of requests
Vivek Nair describes how a team hardened the Claude Docs backend before its September 2026 launch by running Claude in a long-lived loop against a chaos-testing staging cluster. Key lessons include using copy-on-write to fix per-keystroke memory growth, which cut projected pods from over 500 to about 50, and choosing Rust with minimal dependencies so telemetry traces back to owned code. The launch saw 60 server errors across 2 billion requests with no rollbacks.
How the Claude Code team thinks about verification
The post explains how the Claude Code team uses end-to-end, property, and differential tests to let coding agents verify their work with evidence. It also describes the practices used to keep verifiers honest, including a commit gate, a reliability checklist tied to diffs, and evaluations that measure review recall against past incidents.
Building strong safety evaluations
The post gives Anthropic's recommendations for designing, running, and reporting AI safety evaluations, drawing on lessons from the company's system cards. Key points include matching eval design to the question, measuring the right construct (such as appropriate response rate in multi-turn conversations rather than refusal rate), calibrating LLM graders against human labels, preregistering analyses, and reporting uncertainty and configuration fully.
Safely scaling multi-agent teams with Claude Fable 5.2
Anthropic describes a toy experiment in which 1,000 agents running an early Claude model formalized Fermat's Last Theorem in Lean using only general tools, a shared SQL database, and Git, with no specialized platform or researcher steering. The post details how the agents self-organized through database tables, built a task tree to decompose the hardest statement, and operated under layered sandboxing and real-time and offline monitoring.
The components of agent memory
Anthropic describes how Claude manages agent memory, including memory notes written during sessions and a 'dreaming' process that replays transcripts offline to correct errors, build wiki-style memory representations, and promote notes into preloaded context. The post reports evaluations on CL-Bench, Pokémon Red, and a 350,000-file corpus, with scores showing how memory design choices affect performance.
How the Claude Code team does code review
Anthropic's Claude Code team describes how it reviews agent-written code at high volume, layering automated AI review, security review, risk-tiered human approvals, merge queues, feature flags, and fast rollback. The post reports that merged PRs more than doubled while the revert share fell over 40 percent, and covers convergence problems like capping review rounds and turning incidents into an eval set.
Redesigning source control at Anthropic
Anthropic describes replacing git for its monorepo with Scion, an in-house version control system built for always-online agent clients, after merges grew from about 2,500 to over 30,000 per day. The post covers the design principles, a recursive derived-data mechanism, and a tiered daemon, cache, and server architecture that reports over 99% cache hit rates and a 200x smaller infrastructure footprint than the previous git mirrors.
Building effective agent automations
Lance Martin and CJ Avilla present a reference implementation for scheduled agent automations that reads Slack and GitHub, tracks changes with per-source bookmarks, and posts concise updates. The walkthrough covers credential isolation, failure handling, idempotent delivery, memory, guardrails, and spending limits.
Claude Code in the cloud: a field guide to cloud sessions
Addy Osmani explains how Claude Code cloud sessions isolate tasks in fresh VMs, support parallel development, and preserve work on reviewable branches. The guide covers session architecture, GitHub authentication, environment setup, network controls, testing workflows, and practical trade-offs between local and cloud execution.
Getting started with Claude Code mods
Addy Osmani explains how Claude Code mods work as plugin-hosted hooks, covering event middleware, state that survives hot reloads, custom terminal UI, validation, and testing. The tutorial builds a context-window monitor and examines safeguards and edit-replay workflows using concrete JavaScript and TypeScript examples.
Automating eval design and hillclimbing with Claude
Lance Martin explains how to design reliable evaluations that mirror production, control variance, and avoid overfitting. He also demonstrates how Claude Code’s build-eval and hillclimb commands automate evaluation creation, controlled iteration, held-out testing, and cost or performance optimization.
Building with Claude Sonnet 5.5
Addy Osmani explains when to choose Claude Sonnet 5.5 over Opus 5.5, including pricing, effort tuning, token usage, and model capabilities. The guide also details API migration changes involving adaptive thinking, strict tools, computer-use toolsets, response blocks, caching, and fallback behavior.
Using Claude Code: Spending your effort
Thariq Shihipar examines how Claude Code’s effort settings change model behavior, token use, verification, and edge-case handling. Drawing on hands-on builds and Terminal-Bench 3.0 results, he proposes using low effort for iteration and higher effort for testing, security, and difficult autonomous tasks.
What a task costs on Opus 5.5
Addy Osmani explains how Claude Code task costs arise from turns, cached context, output tokens, model choice, effort levels, compaction, and retries. The post provides pricing examples, optimization tactics, and a practical method for measuring usage on real sessions.
How we made claude.ai 3x faster in two weeks
Anthropic engineers describe a two-week sprint that made claude.ai and its desktop app roughly three times faster. They explain how deterministic benchmarks, telemetry, feature flags, incremental rollouts, and Claude-driven optimization threads enabled more than 3,000 safe performance changes.
Getting the most out of Opus 5.5 in Claude and Claude Code
The guide explains how to prompt Opus 5.5, define completion criteria, steer long Claude Code runs, delegate work to subagents, and preserve task state. It also covers reviewing results, handling safety-model switches, and using fast mode in Claude apps and Claude Code.
The new rules of context engineering for Claude 5 generation models
Thariq Shihipar explains how Claude Code reduced its system prompt by more than 80% for newer models without measurable coding-evaluation loss. The post presents practical context-engineering principles, including progressive disclosure, expressive tool design, lighter instructions, auto-memory, and richer references for agent workflows.
Lessons from building Claude Code: How we use skills
Thariq Shihipar explains how Anthropic builds and scales Claude Code skills across development workflows. The post presents nine skill categories and practical patterns for progressive disclosure, gotchas, verification, hooks, reusable scripts, distribution, composition, and usage measurement.
A harness for every task: dynamic workflows in Claude Code
Anthropic explains how Claude Code dynamically creates and orchestrates multi-agent JavaScript workflows for complex tasks. The post details patterns such as fan-out synthesis, adversarial verification, tournaments, root-cause investigation, triage, and model routing, along with guidance on token budgets, isolation, and when coordination costs outweigh the benefits.