Skip to content
Anthropic Engineering Playbook
On Trove · from Anthropic

Anthropic Engineering Playbook

Agents, Harnesses & Infrastructure

A consolidated collection of roughly 88 Anthropic engineering posts in 47 parts.

Read a preview

You can read the contents and the first 2,000 characters.
Free accounts get the whole book.

  • By Sahar Carmel
  • 48 chapters
  • Updated Nov 1, 2026
  • 149 readers

What’s inside

  • Agent Architecture & SDK
  • Harness Design & Autonomy
  • Agent Skills & Distribution
  • Context & Retrieval
  • Evaluation
  • Trust & Industry Trends

What is Anthropic Engineering Playbook?

A consolidated collection of roughly 88 Anthropic engineering posts in 47 parts, covering agent architecture, harness design, multi-agent orchestration, agent skills and their evaluation, MCP, contextual retrieval, evals, containment and agent security, context engineering, tool design, long-running agents, production API surfaces, engineering organizations, and Claude Code. Parts 1-6 digest 13 posts thematically; Parts 7-32 render one post per part; Parts 33-47 group closely related posts by theme. Sources both Anthropic engineering surfaces - anthropic.com/engineering and claude.com/blog - and is complete against both for engineering content as of September 3, 2026, excluding customer stories, buyer guides and release announcements. Includes the full text of Building Effective Agents, Effective Context Engineering, Writing Effective Tools, Advanced Tool Use, Code Execution with MCP, Effective Harnesses for Long-Running Agents, the parallel-Claudes C compiler, Demystifying Evals, Claude Code Best Practices, Beyond Permission Prompts, How Anthropic Teams Use Claude Code, the multi-agent research system, the think tool, SWE-bench Verified, infrastructure noise in evals, agent containment, the 2025 and 2026 quality postmortems, dynamic workflows, Claude Managed Agents, self-service data analytics, the Claude 5 context-engineering rules, the Skills and Files APIs, zero trust and AI-native SDLC security, agents on CI/CD call, computer and browser use, prompt caching, steering and subagents, multi-agent coordination patterns, MCP in production, agent identity, AI-native engineering orgs, partner build write-ups from Datadog and CodeRabbit, Claude Code hooks and CLAUDE.md, structured outputs, and skill evaluation.

Read more

markdown · Listed May 3, 2026

  • best-practices
  • blog
  • harness
  • agents
  • prompting-guide
  • llms

From the first page

A consolidated collection of roughly 88 Anthropic engineering posts covering agent architecture, harness design, multi-agent orchestration, agent skills, MCP, contextual retrieval, evaluation design, containment and agent security, context engineering, tool design, long-running agents, production API surfaces, engineering organizations, and Claude Code. Parts 1-6 are thematic digests of 13 posts. Parts 7-32 render one post per part. Parts 33-47 group closely related posts into a single thematic part each.

Sources are both of Anthropic's engineering surfaces: the original blog at anthropic.com/engineering, and the newer engineering and agents writing at claude.com/blog, where most 2026 material now appears.

Preview · 2,000 of 839,168 characters

Google Gemini Prompting Best Practices
OpenAI Prompting Best Practices
Inside Claude Code: The Architecture
Distributed Task Reliability for AI Agents: Idempotency, Retries & Queues

Contents

  1. 01Anthropic Engineering Playbook: Agents, Harnesses & Infrastructurep.1
    1. How to read this bookp.1
    2. Contentsp.1
  2. 02Agent Architecture & SDKp.2
    1. 1.1 Building Agents with the Claude Agent SDKp.2
    2. 1.2 Scaling Managed Agents: Decoupling the Brain from the Handsp.2
  3. 03Harness Design & Autonomyp.3
    1. 2.1 Harness Design for Long-Running Application Developmentp.3
    2. 2.2 Claude Code Auto Mode: A Safer Way to Skip Permissionsp.3
  4. 04Agent Skills & Distributionp.4
    1. 3.1 Equipping Agents for the Real World with Agent Skillsp.4
    2. 3.2 Desktop Extensions: One-Click MCP Server Installationp.4
    3. 3.3 New Capabilities for Building Agents on the Anthropic APIp.4
  5. 05Context & Retrievalp.5
    1. 4.1 Introducing the Model Context Protocolp.5
    2. 4.2 Introducing Contextual Retrievalp.5
  6. 06Evaluationp.6
    1. 5.1 Designing AI-Resistant Technical Evaluationsp.6
    2. 5.2 Eval Awareness in Claude Opus 4.6's BrowseComp Performancep.6
  7. 07Trust & Industry Trendsp.7
    1. 6.1 Trustworthy Agents in Practicep.7
    2. 6.2 2026 Agentic Coding Trends Reportp.7
  8. 08Building Effective Agentsp.8
    1. Chapter 1: Introductionp.8
    2. Chapter 2: What Are Agents?p.8
    3. Chapter 3: When (and When Not) to Use Agentsp.8
    4. Chapter 4: When and How to Use Frameworksp.8
    5. Chapter 5: The Augmented LLM - The Foundationp.8
    6. Chapter 6: Workflow Pattern - Prompt Chainingp.8
    7. Chapter 7: Workflow Pattern - Routingp.8
    8. Chapter 8: Workflow Pattern - Parallelizationp.8
    9. +8 more sections
See all 48 parts
  1. 09Effective Context Engineering for AI Agentsp.9
    1. Chapter 1: Introduction -- From Prompt Engineering to Context Engineeringp.9
    2. Chapter 2: Why Context Engineering Matters for Capable Agentsp.9
    3. Chapter 3: The Anatomy of Effective Contextp.9
    4. Chapter 4: Context Retrieval and Agentic Searchp.9
    5. Chapter 5: Context Engineering for Long-Horizon Tasksp.9
    6. Chapter 6: Practical Principles and Conclusionp.9
    7. Appendix: Key Concepts Referencep.9
  2. 10Writing Effective Tools for Agentsp.10
    1. Chapter 1: The Fundamental Challengep.10
    2. Chapter 2: The Three-Phase Development Processp.10
    3. Chapter 3: Choosing the Right Toolsp.10
    4. Chapter 4: Namespacing and Organizationp.10
    5. Chapter 5: Designing Tool Responsesp.10
    6. Chapter 6: Token Efficiency and Error Handlingp.10
    7. Chapter 7: Description Engineeringp.10
    8. Chapter 8: Evaluation Methodologyp.10
    9. +3 more sections
  3. 11Advanced Tool Use: Dynamic Tool Discovery, Programmatic Execution, and Reliable Invocationp.11
    1. Table of Contentsp.11
    2. Chapter 1: Introductionp.11
    3. Chapter 2: The Three Bottlenecks of Agent Tool Usep.11
    4. Chapter 3: Tool Search Tool -- Dynamic Discovery Over Static Loadingp.11
    5. Chapter 4: Programmatic Tool Calling -- Code-Driven Orchestrationp.11
    6. Chapter 5: Tool Use Examples -- Teaching Through Demonstrationp.11
    7. Chapter 6: Best Practicesp.11
    8. Chapter 7: Getting Startedp.11
    9. +1 more section
  4. 12Code Execution with MCP: Building More Efficient Agentsp.12
    1. Chapter 1: The Scaling Challengep.12
    2. Chapter 2: Problem -- Tool Definition Overloadp.12
    3. Chapter 3: Problem -- Intermediate Results Bloatp.12
    4. Chapter 4: The Solution -- Code Execution Architecturep.12
    5. Chapter 5: Progressive Disclosure of Toolsp.12
    6. Chapter 6: Context-Efficient Data Filteringp.12
    7. Chapter 7: Enhanced Control Flowp.12
    8. Chapter 8: Privacy Preservationp.12
    9. +4 more sections
  5. 13Effective Harnesses for Long-Running Agentsp.13
    1. Chapter 1: The Long-Running Agent Problemp.13
    2. Chapter 2: The Two-Agent Architecturep.13
    3. Chapter 3: The Feature List Systemp.13
    4. Chapter 4: Getting Up to Speed -- The Session Startup Protocolp.13
    5. Chapter 5: Testing and Verificationp.13
    6. Chapter 6: Git Integration and State Managementp.13
    7. Chapter 7: Failure Modes and Solutionsp.13
    8. Chapter 8: Structured Artifacts Over Implicit Contextp.13
    9. +3 more sections
  6. 14Building a C Compiler with a Team of Parallel Claudesp.14
    1. Chapter 1: Introductionp.14
    2. Chapter 2: The Agent Teams Architecturep.14
    3. Chapter 3: Parallelization and Specializationp.14
    4. Chapter 4: Technical Achievementsp.14
    5. Chapter 5: Design Lessons for Autonomous Systemsp.14
    6. Chapter 6: The Edge of Capabilityp.14
    7. Chapter 7: Autonomy, Safety, and the Human Rolep.14
    8. Chapter 8: Key Takeawaysp.14
  7. 15Demystifying Evals for AI Agentsp.15
    1. Chapter 1: Introductionp.15
    2. Chapter 2: The Structure of an Evaluationp.15
    3. Chapter 3: Why Build Evaluations?p.15
    4. Chapter 4: Types of Graders for Agentsp.15
    5. Chapter 5: Capability Versus Regression Evalsp.15
    6. Chapter 6: Evaluating Coding Agentsp.15
    7. Chapter 7: Evaluating Conversational Agentsp.15
    8. Chapter 8: Evaluating Research Agentsp.15
    9. +6 more sections
  8. 16Claude Code: Best Practices for Agentic Codingp.16
    1. Prefacep.16
    2. Chapter 1: The Fundamental Constraintp.16
    3. Chapter 2: Give Claude a Way to Verify Its Workp.16
    4. Chapter 3: Explore First, Then Plan, Then Codep.16
    5. Chapter 4: Provide Specific Context in Your Promptsp.16
    6. Chapter 5: Configure Your Environmentp.16
    7. Chapter 6: Communicate Effectivelyp.16
    8. Chapter 7: Manage Your Sessionp.16
    9. +5 more sections
  9. 17Beyond Permission Prompts: Making Claude Code More Secure and Autonomousp.17
    1. Chapter 1: The Problem of Permission Fatiguep.17
    2. Chapter 2: The Sandboxing Solutionp.17
    3. Chapter 3: Technical Architecturep.17
    4. Chapter 4: Sandbox Configurationp.17
    5. Chapter 5: Git Handling in the Web Versionp.17
    6. Chapter 6: Impact and Resultsp.17
    7. Chapter 7: The Broader Implications for Agent Securityp.17
    8. Resourcesp.17
  10. 18How Anthropic Teams Use Claude Codep.18
    1. Contentsp.18
    2. Claude Code for Data Infrastructurep.18
    3. Claude Code for Product Developmentp.18
    4. Claude Code for Security Engineeringp.18
    5. Claude Code for Inferencep.18
    6. Claude Code for Data Science and Visualizationp.18
    7. Claude Code for APIp.18
    8. Claude Code for Growth Marketingp.18
    9. +3 more sections
  11. 19How We Built Our Multi-Agent Research Systemp.19
    1. Chapter 1: Why Research Cannot Be a Fixed Pipelinep.19
    2. Chapter 2: The Orchestrator-Worker Architecturep.19
    3. Chapter 3: Compression, Separation of Concerns, and the Numbersp.19
    4. Chapter 4: The Cost, and When Not to Use Thisp.19
    5. Chapter 5: Prompt Engineering for Orchestrationp.19
    6. Chapter 6: Search Behavior, Thinking, and Parallelismp.19
    7. Chapter 7: Tool Design and Agents That Improve Themselvesp.19
    8. Chapter 8: Evaluating Agents That Take Different Pathsp.19
    9. +3 more sections
  12. 20The "Think" Tool - Enabling Claude to Stop and Think in Complex Tool Use Situationsp.20
    1. Chapter 1: What the "Think" Tool Isp.20
    2. Chapter 2: "Think" Versus Extended Thinkingp.20
    3. Chapter 3: The Tool Definitionp.20
    4. Chapter 4: Performance on tau-Benchp.20
    5. Chapter 5: Performance Analysis and SWE-Benchp.20
    6. Chapter 6: When to Use Itp.20
    7. Chapter 7: Implementation Best Practicesp.20
    8. Chapter 8: When Not to Use Itp.20
    9. +1 more section
  13. 21Raising the Bar on SWE-bench Verifiedp.21
    1. Chapter 1: The Benchmark and the Resultp.21
    2. Chapter 2: Minimal Scaffolding, Maximum Model Controlp.21
    3. Chapter 3: The Promptp.21
    4. Chapter 4: The Bash Toolp.21
    5. Chapter 5: The Edit Toolp.21
    6. Chapter 6: A Trajectoryp.21
    7. Chapter 7: Challengesp.21
    8. Chapter 8: Takeawaysp.21
  14. 22Quantifying Infrastructure Noise in Agentic Coding Evalsp.22
    1. Chapter 1: The Claimp.22
    2. Chapter 2: How the Problem Surfacedp.22
    3. Chapter 3: The Experimentp.22
    4. Chapter 4: What the Eval Ends Up Measuringp.22
    5. Chapter 5: Replication, SWE-bench, and Other Confoundersp.22
    6. Chapter 6: The Recommendationp.22
    7. Chapter 7: Why It Matters for Reading Leaderboardsp.22
    8. Chapter 8: Operating Rulesp.22
  15. 23How We Contain Claude Across Productsp.23
    1. Chapter 1: Capping the Blast Radiusp.23
    2. Chapter 2: Three Types of Risk, Three Components of Defensep.23
    3. Chapter 3: Pattern 1 - The Ephemeral Containerp.23
    4. Chapter 4: Pattern 2 - The Human-in-the-Loop Sandboxp.23
    5. Chapter 5: Pattern 3 - The Local VMp.23
    6. Chapter 6: Trusting What the Agent Readsp.23
    7. Chapter 7: Looking Aheadp.23
    8. Chapter 8: Design Rules for Containing an Agent in Productionp.23
  16. 24Postmortems - When Infrastructure, Not the Model, Degrades Qualityp.24
    1. Chapter 1: The Shared Claim - Quality Regressions Are Bugs, Not Policyp.24
    2. Chapter 2: Bug One - The Context Window Routing Errorp.24
    3. Chapter 3: Bug Two - Output Corruption on TPU Serversp.24
    4. Chapter 4: Bug Three - Approximate Top-k XLA:TPU Miscompilationp.24
    5. Chapter 5: Why Three Overlapping Bugs Resisted Diagnosisp.24
    6. Chapter 6: The Process Changes After September 2025p.24
    7. Chapter 7: April 2026 - What Users Reported and Where the Fault Was Notp.24
    8. Chapter 8: The Reasoning Effort Downgrade (March 4 - April 7, 2026)p.24
    9. +3 more sections
  17. 25A Harness for Every Task - Dynamic Workflows in Claude Codep.25
    1. Chapter 1: The Harness Problemp.25
    2. Chapter 2: What a Dynamic Workflow Isp.25
    3. Chapter 3: Three Failure Modes a Single Context Window Cannot Fixp.25
    4. Chapter 4: The Orchestration Primitivesp.25
    5. Chapter 5: Context and Token Economicsp.25
    6. Chapter 6: The Six Core Patternsp.25
    7. Chapter 7: Use Casesp.25
    8. Chapter 8: Prompting Strategiesp.25
    9. +2 more sections
  18. 26Claude Managed Agents - Agentic Surfaces, Dreaming, Outcomes, Orchestration, Sandboxes, and MCP Tunnelsp.26
    1. Chapter 1: Three Posts, One Platform Snapshotp.26
    2. Chapter 2: The Three Phases of Agentic Surfacesp.26
    3. Chapter 3: Decoupling the Brain from the Handsp.26
    4. Chapter 4: The Three Core Resourcesp.26
    5. Chapter 5: Why a Managed Harness Tracks the Modelp.26
    6. Chapter 6: Platform Capabilities at a Glancep.26
    7. Chapter 7: Reported Production Deploymentsp.26
    8. Chapter 8: Dreaming - Curating Memory Between Sessionsp.26
    9. +7 more sections
  19. 27How Warp Builds Self-Improving Agents on Claudep.27
    1. Chapter 1: The System Under Discussionp.27
    2. Chapter 2: The Two-Skill Architecturep.27
    3. Chapter 3: Harvesting Signal From Real Usagep.27
    4. Chapter 4: The Loop In Action - Issue Triagep.27
    5. Chapter 5: Writing Skills That Can Be Improvedp.27
    6. Chapter 6: Failure Modes and Safeguardsp.27
    7. Chapter 7: Transferable Lessonsp.27
  20. 28Self-Service Data Analytics at Anthropic - The Agentic Data Stackp.28
    1. Chapter 1: The Headline Resultp.28
    2. Chapter 2: Data Is Not Softwarep.28
    3. Chapter 3: Layer One - Data Foundationsp.28
    4. Chapter 4: Layer Two - Sources of Truthp.28
    5. Chapter 5: Layer Three - Skills, and the Semantic Layer as Routerp.28
    6. Chapter 6: Layer Four - Validationp.28
    7. Chapter 7: What Did Not Workp.28
    8. Chapter 8: Claude Tag in Slack - A Different Problemp.28
    9. +4 more sections
  21. 29The New Rules of Context Engineering for Claude 5 Generation Modelsp.29
    1. Chapter 1: The Prompt Is a Small Part of the Contextp.29
    2. Chapter 2: Unhobbling Claudep.29
    3. Chapter 3: Give Claude Rules, or Let Claude Use Judgementp.29
    4. Chapter 4: Give Claude Examples, or Design Interfacesp.29
    5. Chapter 5: Put It All Upfront, or Use Progressive Disclosurep.29
    6. Chapter 6: Repeat Yourself, or Write Simple Tool Descriptionsp.29
    7. Chapter 7: Memory in CLAUDE.md, or Auto-Memoryp.29
    8. Chapter 8: Simple Specs, or Rich Referencesp.29
    9. +3 more sections
  22. 30Building Production Agents with Computer Use, the Skills API, and the Files APIp.30
    1. Chapter 1: What Shipped, and a Warning About Datesp.30
    2. Chapter 2: Computer Use - Operating Software the Agent Can Seep.30
    3. Chapter 3: The Browser Use Tool - Acting on Structure, Not Pixelsp.30
    4. Chapter 4: Running the Loop - Batch Actions and Failure Propagationp.30
    5. Chapter 5: The Skills API - Packaging Expertise as an Artifactp.30
    6. Chapter 6: Attaching Skills to a Requestp.30
    7. Chapter 7: The Files API - Documents In, Artifacts Outp.30
    8. Chapter 8: Lifecycle, Limits, and the Isolation Boundaryp.30
    9. +3 more sections
  23. 31Zero Trust for Agents and Securing an AI-Native SDLCp.31
    1. Chapter 1: A Note on Sourcesp.31
    2. Chapter 2: The Threat Clockp.31
    3. Chapter 3: Zero Trust Principles and the Impossible-vs-Tedious Testp.31
    4. Chapter 4: What Makes Agentic Systems Differentp.31
    5. Chapter 5: Current Threats to Agentic Systemsp.31
    6. Chapter 6: The Three Capability Tiersp.31
    7. Chapter 7: Agent Identity and Authenticationp.31
    8. Chapter 8: Access Control, Privilege Scoping, and Resource Boundariesp.31
    9. +7 more sections
  24. 32Claude on Call - An Agent as First Responder for CI/CD Failuresp.32
    1. Chapter 1: The 10pm Pagep.32
    2. Chapter 2: The Setup - Claude Tag as a Channel Participantp.32
    3. Chapter 3: Detection - Filtering Alerts Against oncall.mdp.32
    4. Chapter 4: Triage - Orchestrator and Executor Subagentsp.32
    5. Chapter 5: Memory - lessons.md and Investigation Skillsp.32
    6. Chapter 6: Resolution - The Boundary of Autonomyp.32
    7. Chapter 7: Verification, Communication, and Handoffp.32
    8. Chapter 8: Failure Modes and Multi-Player Modep.32
    9. +2 more sections
  25. 33Best Practices for Computer and Browser Usep.33
    1. Chapter 1: Resolution and Scaling Are the Foundationp.33
    2. Chapter 2: Content Ordering in the Messages Arrayp.33
    3. Chapter 3: Model Selection for Clicking Tasksp.33
    4. Chapter 4: Small Targets, Zoom, and Non-Pixel Alternativesp.33
    5. Chapter 5: Tuning Thinking Effortp.33
    6. Chapter 6: Prompt Injection Defensep.33
    7. Chapter 7: Context Managementp.33
    8. Chapter 8: Experimental Techniquesp.33
    9. +2 more sections
  26. 34Lessons from Building Claude Code - Prompt Caching and Skillsp.34
    1. Chapter 1: Cache Rules Everything Around Agentsp.34
    2. Chapter 2: Lay Out the Prompt for Cachingp.34
    3. Chapter 3: Use Messages for Updatesp.34
    4. Chapter 4: Do Not Change Models Mid-Sessionp.34
    5. Chapter 5: Tools and the Cached Prefixp.34
    6. Chapter 6: Compacting Without Breaking the Cachep.34
    7. Chapter 7: The Five Prompt-Caching Lessonsp.34
    8. Chapter 8: What Skills Arep.34
    9. +5 more sections
  27. 35Steering Claude Code - Skills, Hooks, Rules, Subagents, and Verification Loopsp.35
    1. Chapter 1: The Steering Surface - Seven Mechanismsp.35
    2. Chapter 2: CLAUDE.md - Always-On Project Contextp.35
    3. Chapter 3: Rules - Path-Scoped Constraintsp.35
    4. Chapter 4: Skills - Procedures Loaded On Demandp.35
    5. Chapter 5: Hooks - Deterministic Enforcementp.35
    6. Chapter 6: Output Styles and Appending the System Promptp.35
    7. Chapter 7: Choosing a Surface - Comparison and Common Mistakesp.35
    8. Chapter 8: The Agentic Loop and What a Verification Loop Isp.35
    9. +6 more sections
  28. 36Running Claude Code on Real Codebases - Sessions, Context, and Onboardingp.36
    1. Chapter 1: Agentic Search, and Why Setup Bounds Itp.36
    2. Chapter 2: The Harness Is the Productp.36
    3. Chapter 3: Making a Codebase Navigable at Scalep.36
    4. Chapter 4: Context Rot, Prefill, Decode, and the Prompt Cachep.36
    5. Chapter 5: Every Turn Is a Branching Pointp.36
    6. Chapter 6: Compaction, and Why Autocompact Goes Wrongp.36
    7. Chapter 7: Specificity, Noise, and Session Lengthp.36
    8. Chapter 8: Subagents and Their Limitsp.36
    9. +4 more sections
  29. 37Auto Mode, Model Choice, and Effort Levels in Claude Codep.37
    1. Chapter 1: Scope, and a Freshness Warningp.37
    2. Chapter 2: The Two Dials Are Orthogonalp.37
    3. Chapter 3: Fable, Opus, Sonnetp.37
    4. Chapter 4: Diagnosing a Failure with One Questionp.37
    5. Chapter 5: Token Economics, Including the Inversionp.37
    6. Chapter 6: Opus 4.7 Effort Tiers Inside the Coding Harnessp.37
    7. Chapter 7: Adaptive Thinking Replaces Budgetsp.37
    8. Chapter 8: Behavior Shifts in 4.7 That Change Harness Designp.37
    9. +4 more sections
  30. 38Multi-Agent Coordination Patterns and When to Use Themp.38
    1. Chapter 1: A Gate, Then a Menup.38
    2. Chapter 2: Start With One Agentp.38
    3. Chapter 3: The Three Constraints That Justify Splittingp.38
    4. Chapter 4: Price the Architecture Firstp.38
    5. Chapter 5: Decompose by Context, Not by Job Titlep.38
    6. Chapter 6: The Verification Subagent and the Early Victory Problemp.38
    7. Chapter 7: Pattern 1, Generator-Verifierp.38
    8. Chapter 8: Pattern 2, Orchestrator-Subagentp.38
    9. +4 more sections
  31. 39Agent Harness Design Patterns and the 2026 Workflow Pattern Vocabularyp.39
    1. Chapter 1: The Harness, and Why It Rotsp.39
    2. Chapter 2: Pattern 1 - Lean on the Model, Not the Harnessp.39
    3. Chapter 3: Pattern 2 - Strip Your Agent Harness Downp.39
    4. Chapter 4: Pattern 3 - Set Boundaries Carefullyp.39
    5. Chapter 5: The Second Post - Three Workflow Patternsp.39
    6. Chapter 6: The Decision Framework and the Escalation Ladderp.39
    7. Chapter 7: What This Adds to Building Effective Agentsp.39
    8. Chapter 8: Takeawaysp.39
  32. 40Agent Skills - How They Compare to Prompts, Projects, MCP, and Subagentsp.40
    1. Chapter 1: The Mechanism Selection Problemp.40
    2. Chapter 2: What a Skill Isp.40
    3. Chapter 3: Progressive Disclosure and the Context Budgetp.40
    4. Chapter 4: Skills Compared to Prompts and Projectsp.40
    5. Chapter 5: Skills Compared to MCP Serversp.40
    6. Chapter 6: Composing Skills with MCP Serversp.40
    7. Chapter 7: Skills Compared to Subagentsp.40
    8. Chapter 8: Creating a Skillp.40
    9. +5 more sections
  33. 41MCP in Production - Reaching Real Systems and the 2026 Spec Revisionp.41
    1. Chapter 1: Three Ways an Agent Reaches a Systemp.41
    2. Chapter 2: Production Agents Run in the Cloudp.41
    3. Chapter 3: Build Remote, and Shape Tools Around Intentp.41
    4. Chapter 4: Code Orchestration for Large Surfacesp.41
    5. Chapter 5: Rich Semantics - MCP Apps and Elicitationp.41
    6. Chapter 6: Standardized Auth and Delegated Credentialsp.41
    7. Chapter 7: Client-Side Context Efficiencyp.41
    8. Chapter 8: Pairing MCP Servers with Skillsp.41
    9. +3 more sections
  34. 42Agent Identity, LLM-Assisted Code Security, and AI-Accelerated Offensep.42
    1. Chapter 1: Why Acting As The User Breaks Downp.42
    2. Chapter 2: The Agent Identity Modelp.42
    3. Chapter 3: The Find-and-Fix Loop and the Threat Modelp.42
    4. Chapter 4: Sandboxing for Vulnerability Workp.42
    5. Chapter 5: Discovery Optimizes for Recallp.42
    6. Chapter 6: Verification Optimizes for Precisionp.42
    7. Chapter 7: Triage as the New Bottleneckp.42
    8. Chapter 8: Patching and the Validation Ladderp.42
    9. +5 more sections
  35. 43AI-Native Engineering Organizations, Human-Agent Teams, and Large Migrationsp.43
    1. Chapter 1: The Bottleneck Movedp.43
    2. Chapter 2: Just-in-Time Planning and Context Gatheringp.43
    3. Chapter 3: Review, and What Humans Keepp.43
    4. Chapter 4: Team Makeup, Principles, and Pod Autonomyp.43
    5. Chapter 5: Three Numbers to Trackp.43
    6. Chapter 6: Multiplayer Agents and the Prerequisites for Membershipp.43
    7. Chapter 7: Work in Public, Because Unwritten Context Does Not Existp.43
    8. Chapter 8: Rosters, Roles, and Tool Accessp.43
    9. +5 more sections
  36. 44Partner Build Write-Ups - Datadog's Universal Tool and CodeRabbit's Orchestration Systemp.44
    1. Chapter 1: The Machine Tool Analogyp.44
    2. Chapter 2: The Road to Temperp.44
    3. Chapter 3: The Inversion and the Three Contractsp.44
    4. Chapter 4: Four Verification Layersp.44
    5. Chapter 5: Why Not Just Build a CRUD Appp.44
    6. Chapter 6: Temper as Consolidationp.44
    7. Chapter 7: CodeRabbit - The Implicit Knowledge Failure Modep.44
    8. Chapter 8: The Orchestration Layer and Model Routingp.44
    9. +2 more sections
  37. 45Working With the Grain of the Model - Perception, Artifacts, and Loopsp.45
    1. Chapter 1: Seeing Like an Agent - Tools Shaped to Abilityp.45
    2. Chapter 2: Building and Retiring Tools - Two Case Studiesp.45
    3. Chapter 3: Letting the Agent Find Its Own Contextp.45
    4. Chapter 4: Adding Capability Without Adding a Toolp.45
    5. Chapter 5: Why HTML Beats Markdown as an Agent Artifactp.45
    6. Chapter 6: The HTML Use Casesp.45
    7. Chapter 7: Unknowns - The Map and the Territoryp.45
    8. Chapter 8: Pre-Implementation Patternsp.45
    9. +4 more sections
  38. 46Claude Code Foundations - Hooks, CLAUDE.md, and the Agentic Coding Onrampp.46
    1. Chapter 1: How to Read This Partp.46
    2. Chapter 2: What Agentic Coding Isp.46
    3. Chapter 3: The Permission Model as the Review Surfacep.46
    4. Chapter 4: CLAUDE.md - What It Is and Where It Livesp.46
    5. Chapter 5: What Belongs in CLAUDE.mdp.46
    6. Chapter 6: Documenting Tools and Workflowsp.46
    7. Chapter 7: Keeping CLAUDE.md Alivep.46
    8. Chapter 8: Hooks - The Eight Eventsp.46
    9. +6 more sections
  39. 47Platform Primitives and Domain Specialization - Structured Outputs, Caching, Context Management, and Skills for Hard Domainsp.47
    1. Chapter 1: Reading Note - These Posts Are Datedp.47
    2. Chapter 2: Structured Outputs - Removing the Parse Failurep.47
    3. Chapter 3: Structured Outputs - The API Shapep.47
    4. Chapter 4: Structured Outputs - Schema Limits and Hidden Costsp.47
    5. Chapter 5: Prompt Caching - The Reusable Prefixp.47
    6. Chapter 6: Prompt Caching - Price, TTL, and Invalidationp.47
    7. Chapter 7: Prompt Caching - What the Launch Numbers Showedp.47
    8. Chapter 8: Context Management - Context Editingp.47
    9. +7 more sections
  40. 48Testing and Refining Agent Skills, and Filtering What Search Returnsp.48
    1. Chapter 1: The Gap That Evals Closep.48
    2. Chapter 2: The Eval Artifactp.48
    3. Chapter 3: Running Paired Executionsp.48
    4. Chapter 4: Grading and Execution Metricsp.48
    5. Chapter 5: Benchmark Mode and Variancep.48
    6. Chapter 6: Blind Comparisonp.48
    7. Chapter 7: The Human Review Loopp.48
    8. Chapter 8: Optimizing the Description for Triggeringp.48
    9. +2 more sections