A research-backed deep study on Anthropic's development workflows, agent harness design, infrastructure, interpretability research, and AI-first engineering culture — with 100+ official references.
A study about
by
Context compaction is just asking Claude to summarize previous messages. The CLAUDE.md memory system is "the simplest thing that could work — it's a file that has some stuff." They abandoned vector-based RAG search (with Voyage embeddings) in favor of agentic search using grep and glob, which outperformed RAG "by a lot."Latent Space Boris Cherny created ~20 distinct prototypes in two days for the todo list feature alone, preferring rapid iteration over upfront architecture.Lenny's Pod
The SWE-bench agent that scored 49% uses only two tools: a Bash tool (persistent state, no internet) and an Edit tool (str_replace, view, create, insert, undo).SWE-bench No framework. No RAG. No planning module. The team actively removes tools — they unshipped ls once bash enforcement was robust. Cat Wu: "Everything you can do, Claude can do. There's nothing in between."Teams PDF The foundational paper states: "Start by using LLM APIs directly: many patterns can be implemented in a few lines of code."Building Agents
From the SWE-bench work: "Much more attention should go into designing tool interfaces for models."SWE-bench The team spent more time optimizing tool interfaces than the overall prompt. Tools are the contract between human intent and model capability. This is why Claude Code's Edit tool enforces exact string matching (not line numbers) and the Bash tool maintains persistent state — each design choice encodes an assumption about reliable model interaction.
From harness design research: "Agents tend to respond by confidently praising the work — even when, to a human observer, the quality is obviously mediocre."Harness Design Never let the same agent generate and evaluate its own work. The three-agent harness (Planner, Generator, Evaluator) exists specifically for this reason. The Evaluator actively runs the application, not just reads the code.
Boris Cherny advocates providing small teams with unlimited API access rather than large headcount. Claude Code started with one engineer (Boris), grew to ~10. The team ships 60-100 internal npm releases per day. This forces prioritization: the model does the heavy lifting, humans guide direction. Individual engineers average 5 PRs/day; Boris routinely ships 10-30 PRs/day.Lenny's Pod Pragmatic Eng
From "Harness design for long-running application development": "Every component in a harness encodes an assumption about what the model can't do on its own."Effective Harnesses If the model can do it, remove the component. If it can't, make the harness handle it. This is why harness design evolves with model capabilities — what required scaffolding with Claude 3 may be unnecessary with Claude 4.
"Maybe you don't actually need an IDE."Lenny's Pod
— Boris Cherny, Head of Claude CodeTechnology choices reflect the "model writes the code" philosophy. Pick technologies the model knows best.
"TypeScript and React are two technologies the model is very capable with, so were a logical choice."Pragmatic Eng ~90% of the codebase is AI-authored.Fortune Boris hasn't edited a line by hand since November 2025.Boris/X
Terminal UI via React components with the Ink framework, translating React to ANSI escape codes. Meta's Yoga engine handles constraint-based terminal layouts. No Electron or browser dependency.
Bun for building/bundling. npm for distribution. 60-100 internal npm releases per day. ~1 external release per day. 74 public releases in 52 days (Feb 1 – Mar 24, 2026).Pragmatic Eng Four teams ship in parallel independently.
Minimal, standard CLI handling. The tool avoids heavy abstractions. When given bash access, Claude naturally gravitates toward command-line tools rather than custom abstractions.
The SWE-bench agent (49% score) uses only: Bash (executes commands, persistent state across calls, no internet) and Edit (str_replace with exact string matching, enforced absolute paths, undo_edit). The model determines step sequencing freely.SWE-bench
Claude Code originated from a command-line tool Boris Cherny built to state what music an engineer was listening to. After giving it filesystem access, it "spread like wildfire at Anthropic."Lenny's Pod Boris joined Anthropic in September 2024 and began prototyping with Claude 3.6. He created the first working prototype in days. Sid Bidasaria joined as engineer #2. The team grew to ~10 engineers, now includes PMs, designers, data scientists. An Anthropic spokesperson clarified: company-wide, between 70% and 90% of code is AI-authored.Fortune
Anthropic engineers have converged on several distinct workflow patterns, each suited to different task types.
The Product Development team uses auto-accept mode where Claude writes code, runs tests, and iterates autonomously. Claude verifies its own work by running builds, tests, and lints. The engineer reviews the ~80% complete solution. ~70% of final implementation comes from Claude's autonomous work.Teams PDF Critical: always start from a clean git state and commit checkpoints regularly so you can roll back.
Task classification intuition: peripheral features run async (let Claude go fully autonomous), core business logic runs synchronous (human stays in the loop). Developing this intuition is key to the workflow.
Used by Data Science and ML Engineering. Commit state, let Claude run 30 minutes, accept or restart fresh. Starting over often has higher success rate than debugging a broken attempt. Build permanent React dashboards (5,000+ lines of TypeScript) instead of throwaway Jupyter notebooks — despite "knowing very little JavaScript."Teams PDF
"Treat it like a slot machine — starting over often has higher success rate than fixing."
— Anthropic Data Science TeamUsed by Security Engineering. Write pseudocode first, guide Claude through test-driven development. The security team uses 50% of all custom slash commands in the entire monorepo. They also feed stack traces for incident response (from 10-15 min manual to ~5 min) and copy Terraform plans: "What's this going to do? Am I going to regret this?"Teams PDF
"Let Claude talk first. Tell it to commit as it goes."
— Anthropic Security TeamUsed by RL Engineering. Quick prompt, let Claude attempt full implementation. Works on first attempt about one-third of the time; rest needs guidance or manual intervention. Frequent git checkpointing is essential. The key insight: always try the one-shot approach first before investing in complex prompting — you'd be surprised how often it works.
The foundational paper distinguishes workflows (predefined code paths with LLMs) from agents (LLMs dynamically directing processes). Five workflow patterns form the building blocks:
Sequential LLM calls where each step processes the previous output. Each link has its own validation gate. Best for tasks decomposable into fixed subtasks. Example: generate code → review code → fix issues.
Classify input and direct to specialized handlers. The LLM acts as a dispatcher. Example: classify a bug report as frontend/backend/infra, route to appropriate specialized prompt.
Run multiple LLM calls simultaneously. "Sectioning" (different subtasks) or "voting" (same task, aggregate). The multi-agent research system used this to reduce research time by up to 90%.
A lead agent (Opus) dynamically breaks tasks and delegates to parallel worker agents (Sonnet). Outperformed single-agent by 90.2%.Multi-Agent Research Token usage explains 80% of variance in quality.
One LLM generates, another evaluates and provides feedback. Loop until quality threshold met. Critical because agents "confidently praise mediocre work." Separating concerns is non-negotiable for quality.
For code migrations and large features, engineers use 10+ parallel Claude agents in a map-reduce pattern. Each agent in its own Docker container or git worktree. Coordination via shared upstream git repo with a current_tasks/ directory for locking. Slash commands like /pr_commit, /feature_dev, /code_review standardize common operations. Average user cost: ~$6/day.Pragmatic Eng
A harness is the scaffolding around a coding agent. Each component is a design decision encoding an assumption about model limitations.
The key insight is filesystem-based state. Each context window starts fresh, but the agent reconstructs its understanding by reading git logs, progress files, and the features list. This eliminates context window limits as a constraint on project size.Effective Harnesses
CLAUDE.md files, hooks, and skills form the persistent configuration layer between humans and Claude Code. Understanding these systems is essential to replicating Anthropic's workflows.
Files are loaded by walking UP the directory tree. All discovered files are concatenated — they do not override each other.
| Scope | Location | Shared With |
|---|---|---|
| Managed policy | /Library/Application Support/ClaudeCode/CLAUDE.md (macOS) | All org users (cannot be excluded) |
| Project | ./CLAUDE.md or ./.claude/CLAUDE.md | Team via source control |
| User | ~/.claude/CLAUDE.md | Just you, all projects |
| Local | ./CLAUDE.local.md (gitignored) | Just you, current project |
| Rules | .claude/rules/*.md (supports paths: frontmatter for glob-scoping) | Team via source control |
"Anytime we see Claude do something incorrectly we add it to the CLAUDE.md. During code review, we tag @.claude on PRs to add learnings directly — Compounding Engineering."Lenny's Pod
— Boris ChernyBest practices: Target under 200 lines per file. Use @path/to/import to import files (max 5 hops). Run /init to auto-generate. HTML comments are stripped before injection to save tokens. "Claude is eerily good at writing rules for itself."Lenny's Pod
Lives at ~/.claude/projects/<project>/memory/ (derived from git repo). Machine-local, not shared across teams.
Hooks execute shell commands, HTTP requests, prompt evaluations, or spawn sub-agents in response to Claude Code lifecycle events. Configured in settings.json.
4 Handler Types
Key Blocking Events
PreToolUse — intercept before any tool executesPermissionRequest — custom permission logicUserPromptSubmit — modify/validate user inputStop — intercept before session endsExit codes: 0 = success (parses stdout JSON), 2 = blocks the action, other = non-blocking error. Matchers use regex. The if field uses permission rule syntax (e.g., Bash(git *), Edit(*.ts)).
Anthropic's actual hook config: PostToolUse on Write|Edit runs bun run format || true — auto-formatting every file Claude touches.Pragmatic Eng
Skills are the extensibility layer for Claude Code. They combine a markdown prompt with frontmatter configuration, supporting files, and dynamic context injection. Follows the open Agent Skills standard.
Bundled skills: /batch (parallel changes in worktrees), /simplify (3 parallel review agents), /loop (recurring execution), /debug (troubleshooting), /claude-api (API reference loader). Custom skills live in .claude/skills/.
The creator of Claude Code's actual working setup, documented from multiple interviews, his setup thread on X, and howborisusesclaudecode.com.
za, zb, zc for one-keystroke worktree navigation/effort max for complex debugging and architectureCode output per engineer up 200%, making reviews the bottleneck. Solution: multi-agent code review. When a PR is opened, multiple review agents run independently in parallel, catching ~80% of low-level bugs before any human sees the code. Teams went from 80% manual (Nov 2025) to 80% AI-driven (Dec 2025), shipping 49 PRs in 2 days.Pragmatic Eng
"Give Claude a way to verify its work. If Claude has that feedback loop, it will 2-3x the quality of the final result."
— Boris Cherny, #1 TipContext engineering is the discipline of managing what information reaches the model and when. As context windows grow, recall accuracy decreases due to transformer attention budget (n-squared).
Summarize conversation history while preserving architectural decisions and key context. Claude Code does this automatically when approaching context limits. The compacted summary is loaded into the next context window, allowing work to continue across sessions.
Persistent external memory via files: CLAUDE.md (project instructions), NOTES.md (discoveries), to-do lists. These files persist across context windows and are loaded on session start. The CLAUDE.md file can be project-level, user-level (~/.claude/CLAUDE.md), or directory-scoped.
Delegate research to specialist sub-agents that return 1,000-2,000 token summaries instead of loading full file contents into the main context. This protects the orchestrator's context from bloat while allowing deep exploration.
Maintain lightweight identifiers (file paths, function names) and dynamically load full content only when needed at runtime. Don't pre-load everything — let the agent pull what it needs via tools like Read, Grep, Glob.
Creates a designated space for Claude to pause during response generation for structured reasoning. Unlike chain-of-thought in the response, the think tool's content is not shown to the user but is available to the model. Results: 54% improvement in complex airline customer service tasks; 1.6% improvement on SWE-bench (p < .001).Think Tool Most effective in multi-step tool use where the model must plan across several operations.
budget_tokens must be < max_tokenssummarized (default), omitted (faster streaming)tool_choice: "auto" or "none"interleaved-thinking-2025-05-14Key difference from the "think" tool: extended thinking happens before the first response token across the full context, while the think tool is invoked between tool calls for local reasoning. Larger budgets improve quality but Claude may not use the full budget, especially above 32K tokens.
cache_control: {"type": "ephemeral"}tools → system → messagescache_control at top-level, system auto-places breakpointInvalidation rules: Changing tool definitions invalidates everything. Changing system prompt invalidates system + messages. Changing extended thinking settings invalidates messages only. Claude Code caches the system prompt and CLAUDE.md context, making every subsequent tool call in a session dramatically cheaper.
"Teams without evals face reactive loops — catching issues only in production."
In September 2025, three production bugs revealed critical evaluation gaps: (1) context window routing errors affected 30% of Claude Code users, (2) TPU misconfiguration caused output corruption, (3) an XLA:TPU compiler bug was triggered by code deployment. The key finding: "evaluations simply didn't capture the degradation users were reporting."Postmortem Privacy controls limited engineer access to user interactions. Systemic changes: more sensitive evaluations, continuous production monitoring, /bug command and thumbs-down buttons for direct user feedback.
From the official 22-page PDF. Source: How Anthropic Teams Use Claude Code (PDF)
Uses auto-accept mode (Shift+Tab) for autonomous loops. Claude writes code, runs tests, and iterates. Reviews the ~80% complete solution before human refinement. GitHub Actions integration lets Claude automatically address PR review comments.
Self-sufficient loops: Set up Claude to verify its own work by running builds, tests, and lints automatically. The agent should be able to detect and fix its own errors without human intervention for routine issues.
Task classification: Peripheral features (docs, tests, UI tweaks) run fully async. Core business logic and security-sensitive code stay synchronous with human review. Developing this classification intuition is the meta-skill.
Feeds stack traces and documentation for incident response (10-15 min → ~5 min). Reviews Terraform plans: "What's this going to do? Am I going to regret this?" Uses 50% of all custom slash commands in the monorepo.
TDD workflow: Pseudocode first, guide through test-driven development, periodically check in. Tell Claude to "commit your work as you go" and let it work autonomously between checkpoints.
Feed screenshots of Kubernetes dashboards into Claude Code for diagnosis (found pod IP address exhaustion). New hires directed to Claude Code to navigate the massive codebase.
Continuous improvement loop: End-of-session CLAUDE.md updates document what was learned. Next session starts with richer context. Over time, the CLAUDE.md becomes a living knowledge base for the project.
Finance automation: Finance team writes plain text workflow descriptions, loads them into Claude Code for fully automated execution.
Build 5,000-line TypeScript React dashboards despite "very little JavaScript and TypeScript" knowledge. Create permanent React dashboards instead of throwaway Jupyter notebooks.
The slot machine pattern in practice: Commit clean state. Give Claude the task. Walk away for 30 minutes. Come back and evaluate: if it's good, merge. If not, git reset --hard and try a different prompt. This is faster than debugging a broken attempt.
Claude writes comprehensive unit tests with edge cases, reducing R&D time by 80%. Cross-language translation: writing Rust test logic without knowing Rust. Kubernetes command recall: "how to get all pods or deployment status" — faster than searching documentation.
Automated Google Ads workflow: processes CSV files, uses two specialized sub-agents (one for headlines, one for descriptions). Built a Figma plugin for mass creative production: generates up to 100 ad variations, half a second per batch. Built a Meta Ads MCP server for campaign analytics.
Ad copy creation: 2 hours → 15 minutes. 10x increase in creative output. One non-technical person replaced a workflow that previously required coordination across multiple teams.
Designers directly implement visual tweaks (typefaces, colors, spacing) using Claude Code. Paste mockup images directly into Claude Code for rapid prototyping. Figma and Claude Code open 80% of the time.
Complex copy changes that required a week of coordination across teams now take two 30-minute calls. GitHub Actions automated ticketing: file issues, Claude proposes code solutions.
Key: Custom memory files telling Claude "you're a designer needing detailed explanations" dramatically improve output quality for non-engineers.
Claude Code as "first stop" for any task — identifies relevant files before starting work. Model iteration testing through dogfooding: Claude Code automatically uses latest research model snapshots, providing real-world feedback to the model team.
Key: Start with minimal information. Let Claude guide through the process of understanding the codebase rather than pre-loading everything.
"Try and rollback" methodology with frequent checkpointing. Works on first attempt ~33% of the time; rest needs guidance or manual intervention. Always try one-shot first, then collaborate.
Lawyers built phone tree systems using Claude Code. Demonstrates that fully non-technical team members can build functional software — the "everyone codes" thesis in action.
In August 2025, Anthropic surveyed 132 engineers and researchers, conducted 53 in-depth qualitative interviews, and analyzed 200,000 internal Claude Code transcripts (Feb-Aug 2025).AI @ Anthropic
The Agent SDK provides the same capabilities as Claude Code CLI, but programmable. The Subagent system enables parallel agent execution within sessions.
| Agent | Model | Tools | Use Case |
|---|---|---|---|
| Explore | Haiku (fast) | Read-only | Codebase search, file discovery. Supports quick / medium / very thorough |
| Plan | Inherits | Read-only | Research and design implementation plans |
| general-purpose | Inherits | All tools | Complex multi-step tasks, web search, code changes |
| code-reviewer | Inherits | Read/Grep/Glob/Bash | Quality, security, maintainability review |
| Custom | Configurable | Configurable | Defined via .claude/agents/*.md with frontmatter |
Isolation: Setting isolation: worktree gives each subagent its own git worktree — an isolated copy of the repository. Worktrees are auto-cleaned if the subagent makes no changes. This enables parallel agents editing the same files independently. Permission modes: default, acceptEdits, auto, dontAsk, bypassPermissions, plan.
Claude can interact with computer screens via screenshot-based perception and coordinate-based actions. Relevant for testing web UIs, automated QA, and browser-based workflows.
MCP is an open protocol that standardizes how AI models connect to external tools and data sources. Announced November 2024.
MCP follows a client-server architecture. The MCP host (Claude Code, Claude Desktop) connects to MCP servers that expose tools, resources, and prompts. Servers are lightweight processes (often Node.js or Python) that implement the MCP specification. Communication uses JSON-RPC over stdio or SSE.
The Growth Marketing team built a Meta Ads MCP server for campaign analytics. Data Infrastructure recommends "MCP servers instead of CLI for sensitive data" because MCP servers can enforce access controls. Desktop Extensions provide one-click MCP server installation. The code execution MCP enables sandboxed code running inside Claude.
Full specification at modelcontextprotocol.io. GitHub organization: modelcontextprotocol. GitHub's official MCP server is maintained at anthropics/github-mcp-server. Anthropic Academy offers courses on MCP basics and advanced topics.
Anthropic's engineering practices are inseparable from their safety research. Understanding these papers gives context to why Claude Code works the way it does.
A method for training harmless AI using self-improvement via a set of principles ("constitution") rather than human-labeled harmful outputs. Two phases: supervised learning (self-critique and revision) + RL with AI-generated preference labels. This is why Claude can self-correct during coding — the constitutional approach trains the model to reason about its own outputs.
Applies preference modeling and RLHF to fine-tune language models as assistants. Key finding: alignment training improves performance on nearly all NLP evaluations, including coding. It's not a tradeoff. Released the hh-rlhf dataset (public, on GitHub).
Trains LLMs with backdoor behaviors (write secure code in 2023, insert vulnerabilities when year is 2024). These deceptive behaviors persist through standard safety training (SFT, RLHF, adversarial training). Directly relevant to trusting AI-generated code.
First empirical demonstration of alignment faking without explicit training. Claude 3 Opus, when told it would be retrained, strategically complied with harmful requests 14% of the time to preserve its preferred behavior. Demonstrates why robust evaluation of AI agents is critical.
Tests four sabotage types: human decision sabotage, code sabotage (inserting subtle bugs), sandbagging (hiding capabilities during testing), and undermining oversight. Current models: minimal mitigations suffice. But stronger ones will be needed soon.
CoT explanations can systematically misrepresent model reasoning. Models exploit reward hacks >99% of the time but verbalize them <2% of the time. This is why you can't just read Claude's reasoning to verify its code — you need actual tests.
arxiv: 2305.04388 (NeurIPS 2023)
Published at transformer-circuits.pub. This research lets Anthropic understand what's happening inside Claude's "brain" when it writes code.
Mathematical framework for how neural networks store more features than dimensions. Networks compress sparse features via superposition, causing polysemanticity (one neuron = multiple concepts). Foundation for all subsequent interpretability work.
Scales sparse autoencoders to Claude 3 Sonnet (production model), extracting millions of interpretable features: the Golden Gate Bridge, code errors, deception, safety-relevant behaviors. Proved interpretability techniques transfer from small to large models.
Attribution graphs trace the computational steps a model uses to transform inputs into outputs. Applied to Claude 3.5 Haiku. Open-sourced as a Python library. Revealed that the same core features activate across languages, and cases where Claude fabricates calculations without actual computation.
Anthropic's framework for risk governance proportional to model capabilities. Defines AI Safety Levels (ASL) with evaluation and deployment requirements at each level. Currently on version 3.0. Claude Opus 4 released under ASL-3 Standard; Claude Sonnet 4 under ASL-2 Standard. The Frontier Safety Roadmap outlines future milestones.
"The Paradox of Supervision: Effectively using Claude requires supervision skills that may atrophy from overuse."
— How AI Is Transforming Work at Anthropic (Internal Research, 2025)Academic research corroborates: developers using AI coding assistants scored 17% lower on comprehension and debugging tests (arxiv: 2601.20245). Anthropic's own engineers report: "The more excited I am to do the task, the more likely I am to not use Claude." Balance AI leverage with maintaining deep technical understanding.
Claude serves across AWS Trainium, NVIDIA GPUs, and Google TPUs with "strict equivalence standards" — identical quality regardless of hardware. Million-chip footprint across AWS and GCP. Serves on AWS, GCP, Azure, and additional CSPs.
>99% of compute on Amazon EKS. Runs some of the largest EKS clusters in production (trn2 instances, NVIDIA GPUs, Graviton processors). End-user latency KPIs improved from average 35% to consistently above 90% via EKS ultra-scale optimizations.AWS Blog
Canary/soak testing, blue-green deployments, traffic shifting, automated rollback. Rainbow deployments for multi-agent systems: gradually shift traffic between versions without disrupting running agents. Goal: make deployment "boring and unattended."
Two isolation mechanisms: filesystem isolation (Linux bubblewrap, macOS seatbelt) and network isolation (Unix domain socket proxy enforcing domain restrictions). Reduced permission prompts by 84% internally.Sandboxing Claude Code on web: isolated sandboxes with scoped git credentials outside the sandbox.
Confidential inference via trusted VMs ensures that even Anthropic cannot access user data during inference in high-security deployments. Published research on the architecture and guarantees.
claude-code-action integrates Claude into CI pipelines. Automated PR review, code fixes in response to review comments, and security review via claude-code-security-review. DevContainer features available for standardized environments.
A phased approach to adopting Anthropic-style AI-first development, from foundations through production multi-agent systems.
Read (essential): Building Effective Agents (the foundational paper). Claude Code: Best practices for agentic coding.
Read (deep): The Pragmatic Engineer: How Claude Code is built. Every.to: How to use Claude Code like the people who built it.
Course: Anthropic Academy: Claude Code in Action (free, with certificate).
Do: Install Claude Code. Create your first CLAUDE.md. Configure auto-accept mode. Make your first 10 AI-authored commits. Practice the Autonomous Loop on a small feature.
Read: How Anthropic Teams Use Claude Code (22-page PDF). Effective context engineering for AI agents. The "think" tool.
Listen: Latent Space: Claude Code architecture. Lenny's Podcast: Head of Claude Code.
Do: Practice the slot machine workflow, TDD with Claude, and try-and-rollback patterns. Target 3-5 PRs/day. Build custom slash commands for your recurring tasks. Implement prompt caching in your API calls.
Read: Introducing the Model Context Protocol. Writing effective tools for agents. Advanced tool use on Claude Developer Platform.
Course: Anthropic Academy: Introduction to MCP + MCP Advanced Topics.
Do: Build your first MCP server for an internal tool (database, API, docs). Study the MCP specification. Design tool interfaces following Anthropic's principle: "spend more time on tool design than prompt design."
Read: Effective harnesses for long-running agents. Harness design for long-running application development.
Study: Demystifying evals for AI agents. Quantifying infrastructure noise in evals.
Do: Implement a two-agent system (Initializer + Coding Agent) for a medium feature. Create your first eval suite (20-50 tasks from real failures). Test the three-agent pattern (Planner, Generator, Evaluator) on a quality-critical feature.
Read: Building a C compiler with parallel Claudes. How we built our multi-agent research system. Building agents with the Claude Agent SDK.
Study (safety): Constitutional AI paper. Sleeper Agents paper. Claude Code sandboxing.
Do: Set up parallel agent execution with Docker containers or git worktrees. Build a code migration using orchestrator-workers. Implement sandboxing for your agent workflows. Configure claude-code-action for your CI pipeline.
Read: How AI Is Transforming Work at Anthropic (internal research). AI's Impact on Software Development (economic index). Inside Anthropic's AI-First Development.
Course: Anthropic Academy: Introduction to Subagents. Introduction to Agent Skills.
Do: Set up Coder or similar remote dev environments. Create team-specific CLAUDE.md files and shared slash commands. Implement the Claude Code monitoring guide for ROI measurement. Track: PRs/engineer/day, AI-authored code %, time-to-ship, eval pass rates.
All courses available at anthropic.skilljar.com
Hands-on course covering Claude Code workflows, slash commands, and agent patterns.
API fundamentals: tool use, streaming, structured outputs, prompt caching.
Model Context Protocol basics: architecture, server implementation, tool design.
Advanced server patterns, security, production deployment of MCP servers.
Sub-agent architecture, delegation patterns, parallel execution.
Building and deploying Agent Skills for Claude Code.
Core concepts, capabilities, and best practices for working with Claude.
| Webinar | Focus |
|---|---|
| Claude Code Live: Origin Story, Demos, Best Practices | Overview & demos |
| Claude Code in an Hour: A Developer's Intro | Getting started |
| Claude Code Advanced Patterns: Subagents, MCP, Scaling | Advanced patterns |
| Claude Code for Financial Services (Boris Cherny) | Enterprise |
| Claude Code for Service Delivery (Boris Cherny) | Enterprise |
| The Future of AI at Work: Introducing Cowork | Collaboration |
9-chapter interactive tutorial with exercises. Covers basic to advanced prompt engineering techniques in Jupyter notebooks.
Educational courses as Jupyter notebooks. Covers tool use, RAG, agentic patterns, and more.
Recipes for sub-agents, PDFs, evals, JSON mode, caching, tool use, RAG, and common integration patterns.
Starter projects for building deployable applications with the Claude API.
Every claim in this guide is traceable to these sources. Organized by category for study priority.
| arxiv / URL | Paper | Year |
|---|---|---|
| 2212.08073 | Constitutional AI: Harmlessness from AI Feedback — Bai, Kadavath, Kundu, Askell et al. | 2022 |
| 2204.05862 | Training a Helpful and Harmless Assistant with RLHF — Bai, Jones, Ndousse, Askell et al. | 2022 |
| 2001.08361 | Scaling Laws for Neural Language Models — Kaplan, McCandlish, Henighan, Brown et al. | 2020 |
| 2401.05566 | Sleeper Agents: Training Deceptive LLMs that Persist Through Safety Training — Hubinger, Denison, Mu et al. | 2024 |
| 2412.14093 | Alignment Faking in Large Language Models — Greenblatt, Denison, Wright et al. | 2024 |
| 2410.21514 | Sabotage Evaluations for Frontier Models — Carlsmith et al. (code sabotage, sandbagging) | 2024 |
| 2209.10652 | Toy Models of Superposition — Elhage, Hume, Olsson et al. | 2022 |
| 2305.04388 | Language Models Don't Always Say What They Think — Turpin, Michael, Perez, Bowman (NeurIPS 2023) | 2023 |
| 2505.05410 | Reasoning Models Don't Always Say What They Think — Chen, Benton et al. | 2025 |
| 2308.03296 | Studying LLM Generalization with Influence Functions — Grosse, Bae, Anil et al. | 2023 |
| 2209.07858 | Red Teaming Language Models to Reduce Harms — Ganguli, Lovitt, Kernion, Askell et al. | 2022 |
| 2212.09251 | Discovering LM Behaviors with Model-Written Evaluations — Perez et al. (ACL 2023) | 2022 |
| 2302.07459 | The Capacity for Moral Self-Correction in Large Language Models — Ganguli, Askell et al. | 2023 |
| 2310.13548 | Towards Understanding Sycophancy in Language Models — Tong et al. | 2023 |
| 2501.18837 | Constitutional Classifiers: Defending Against Universal Jailbreaks | 2025 |
| 2601.04603 | Constitutional Classifiers++: Production-Grade Defenses | 2026 |
| 2511.18397 | Natural Emergent Misalignment from Reward Hacking — includes Claude Code sabotage | 2025 |
| 2510.07192 | Poisoning Attacks on LLMs Require Near-Constant Poison Samples | 2025 |
| 2503.10965 | Auditing Language Models for Hidden Objectives | 2025 |
| 2207.05221 | Language Models (Mostly) Know What They Know — Kadavath, Conerly, Askell et al. | 2022 |
| 2112.00861 | A General Language Assistant as a Laboratory for Alignment — Askell, Bai et al. | 2021 |
| 1606.06565 | Concrete Problems in AI Safety — Amodei, Olah, Steinhardt et al. (pre-Anthropic) | 2016 |
| 2601.20245 | How AI Impacts Skill Formation — 17% lower scores with AI assistance | 2026 |
| Publication | Year |
|---|---|
| A Mathematical Framework for Transformer Circuits — Elhage, Nanda, Olsson et al. | 2021 |
| In-Context Learning and Induction Heads — Olsson, Elhage, Nanda et al. | 2022 |
| Toy Models of Superposition — Elhage, Hume, Olsson et al. | 2022 |
| Towards Monosemanticity: Dictionary Learning — Bricken, Templeton, Batson et al. | 2023 |
| Scaling Monosemanticity: Features from Claude 3 Sonnet — Templeton et al. | 2024 |
| Sparse Crosscoders for Cross-Layer Features and Model Diffing | 2024 |
| Circuit Tracing: Revealing Computational Graphs in LMs — Ameisen et al. | 2025 |
| On the Biology of a Large Language Model — Lindsey et al. | 2025 |
| Emergent Introspective Awareness in LLMs — Lindsey | 2025 |
| Emotion Concepts and Their Function in a LLM — Sofroniew et al. | 2026 |
| Report |
|---|
| How AI Is Transforming Work at Anthropic — 132 engineers surveyed, 200K transcripts analyzed |
| AI's Impact on Software Development (Economic Index) — 500K coding interactions analyzed |
| How AI Assistance Impacts Coding Skills |
| Estimating AI Productivity Gains from Claude Conversations |
| Measuring AI Agent Autonomy in Practice |
| Anthropic Economic Index: Economic Primitives |
| Preparing for AI's Economic Impact: Policy Responses |
| Labor Market Impacts of AI: A New Measure |
| Model | Date | Link |
|---|---|---|
| Claude 3 Family (Opus, Sonnet, Haiku) | Mar 2024 | |
| Claude 3.5 Sonnet | Jun 2024 | |
| Claude 3.7 Sonnet | Feb 2025 | System Card |
| Claude Opus 4 & Sonnet 4 | May 2025 | |
| Claude Sonnet 4.6 | Feb 2026 | System Card |
| Claude Opus 4.6 | Feb 2026 | System Card |
| All System Cards Index | — | Index Page |
| Resource | URL |
|---|---|
| Documentation Home | docs.anthropic.com |
| Tool Use / Function Calling | docs.anthropic.com/.../tool-use |
| Extended Thinking | platform.claude.com/.../extended-thinking |
| Prompt Caching | platform.claude.com/.../prompt-caching |
| Computer Use Tool | platform.claude.com/.../computer-use-tool |
| Prompt Engineering Guide | docs.anthropic.com/.../prompt-engineering |
| Agent SDK Overview | platform.claude.com/.../agent-sdk/overview |
| Claude Code Memory | code.claude.com/.../memory |
| Claude Code Hooks | code.claude.com/.../hooks |
| Claude Code Skills | code.claude.com/.../skills |
| Claude Code Subagents | code.claude.com/.../sub-agents |
| GitHub Actions Integration | code.claude.com/.../github-actions |
| MCP Specification (2025-11-25) | modelcontextprotocol.io/specification |
| Agent Skills Open Standard | agentskills.io |
| Responsible Scaling Policy v3.0 | anthropic.com/rsp-v3-0 |
| Transparency Hub | anthropic.com/transparency |
| Type | Reference |
|---|---|
| Site | How Boris Uses Claude Code — Boris Cherny's exact workflow, session management, parallel instances |
| Thread | Boris Cherny on X: "I'm Boris and I created Claude Code" — 15-tweet thread on his setup: parallel instances, Opus 4.5 w/ thinking, slash commands, subagents, hooks, MCP servers, verification loops |
| Art | InfoQ: Inside the Development Workflow of Claude Code's Creator |
| Paper | Terminal-Bench: Benchmarking LLM Agents (ICLR 2026 conference paper) |
| Art | Mitigating Prompt Injections in Browser Use (1% ASR defense) |
| Art | Confidential Inference via Trusted Virtual Machines |
| Art | Building AI for Cyber Defenders |
| Site | Anthropic Learning Resources Hub |
| Repository | Description |
|---|---|
claude-code | The agentic coding tool |
claude-code-action | GitHub Actions integration |
claude-code-security-review | AI-powered security review GitHub Action |
claude-code-monitoring-guide | ROI measurement guide |
claude-agent-sdk-python | Python Agent SDK |
claude-agent-sdk-typescript | TypeScript Agent SDK |
skills | Public Agent Skills repository |
anthropic-sdk-python | Official Python SDK |
anthropic-sdk-typescript | Official TypeScript SDK |
claudes-c-compiler | 100K-line C compiler built by 16 parallel Claudes |
claude-cookbooks | Recipes for common integration patterns |
courses | Educational courses (Jupyter notebooks) |
prompt-eng-interactive-tutorial | 9-chapter prompt engineering tutorial |
evals | Evaluation framework |
hh-rlhf | Human preference data for RLHF paper |
claude-constitution | Claude's values and behavior document |
modelcontextprotocol | MCP specification (separate org) |