How to Use Claude Code | 5 Extensions + 3 Operations from Anthropic's Employee Playbook

1. What Is Anthropic's Official Playbook "How Anthropic Teams Use Claude Code"?

"How Anthropic Teams Use Claude Code," published on Anthropic's official blog and website around May 12–13, 2026, is a document in which Anthropic employees who use Claude Code daily for work have systematized how they leverage the tool. It was released in two formats — a summary version on the official blog and a full PDF version exceeding 30 pages — and a key distinguishing feature is that it includes usage examples not just from engineering teams, but from non-engineering roles such as sales, marketing, finance, and legal. For teams considering adopting Claude Code, the arrival of an official primary source is enormously significant (source: https://claude.com/blog/how-anthropic-teams-use-claude-code).

1.1 How to Use the Full PDF vs. the Blog Summary

The official blog version is a summary presenting the framework's core "2 capability axes × 5 extensions × 3 operational patterns." The full PDF (https://www-cdn.anthropic.com/58284b19e702b49db9302d5b6f135ad8871e7658.pdf), on the other hand, contains rich concrete examples from individual employees, accounts of failures, and pain points encountered during initial setup — making it highly valuable as material for internal study sessions or consulting proposals. If you're thinking about rolling this out to non-engineering staff, the full PDF is essential; the blog version alone lacks the necessary detail.

1.2 Why Did Anthropic Make Its Internal Case Studies Public?

There are three reasons for publishing this. First, to eliminate the situation where client companies "don't even know how Anthropic itself uses the tool," and to provide a productivity benchmark. Second, to accelerate the growth of the ecosystem of extensions and community plugins surrounding Claude Code. Third, to create a channel for reverse-importing excellent usage patterns that emerge externally. For Anthropic, this decision to make an internal document public can be read as a judgment that the return outweighs the cost.

1.3 Intended Readers and Key Takeaways

The primary audience for the playbook is leads of engineering teams that have already adopted Claude Code, and CTO/VPoE-level decision makers evaluating adoption. The biggest takeaway is the message that "even Anthropic employees don't do everything perfectly from the start" and that "extensions are something you build up incrementally" — which has the effect of relieving pressure on teams in the early stages of adoption. The attitude of "start with one thing today rather than aiming for a perfect setup" runs throughout the document, structuring it in a way that lowers psychological barriers for practitioners.

2. The Two Capability Axes Common Across the Company — Coding / Beyond Coding

The first thing the playbook presents is two axes for organizing Claude Code's capabilities. The first axis is "core coding tasks," covering writing, reading, reviewing, and debugging code — corresponding to the conventional image of AI coding assistance. The second axis is "uses that go beyond code," a broad domain including research, design reviews, documentation, operational tasks, data aggregation, and bridging different job functions — extending all the way to non-engineering work. Within Anthropic, second-axis usage is extremely active even among non-engineering roles, which is an important discovery that challenges most readers' assumptions about how they're using the tool (source: https://claude.com/blog/how-anthropic-teams-use-claude-code).

2.1 Axis 1 — Writing, Reading, and Reviewing Code

Axis 1 covers engineers' core work: new implementations, understanding existing code, PR reviews, debugging, and refactoring. The playbook particularly emphasizes its power with "unfamiliar languages, frameworks, or internal codebases." For example, it introduces a case where an employee who had been writing Python for years was touching a Rust internal service for the first time, and Claude Code functioned as a "comprehension partner." It also has a direct effect on accelerating new employee onboarding.

2.2 Axis 2 — Research, Design, Operations, and Bridging

Axis 2 refers to non-code work. Concrete examples include: a sales team generating draft customer proposals with Claude Code, a marketing team generating article structure outlines, a finance team generating SQL for internal dashboards, and a legal team generating diff summaries of contracts. The point demonstrated is that even non-engineers can break through job-function barriers by writing their team's context into CLAUDE.md.

2.3 The Real Message Behind the Ratio of Two Axes

The fact that second-axis usage — including by non-engineering staff — is extremely active within Anthropic indicates that viewing Claude Code as merely a "code completion tool" is too narrow. When readers introduce it to their own teams, distributing accounts not just to engineers but also to contractors, salespeople, and corporate staff may yield higher ROI. This is one of the most important discoveries conveyed by the playbook.

3. How Employees Enhance Claude Code with 5 Extensions

Here we explain in order the 5 features the playbook organizes as "enhancement axes." Anthropic employees layer these incrementally to build their own custom work environment. The key point is that "you don't need to use everything from the start" — the recommended route is to introduce one, measure its effect, then move on to the next extension. The order below roughly matches the frequency of mention in the playbook, arranged from highest priority (what to tackle first) to lower (source: https://www-cdn.anthropic.com/58284b19e702b49db9302d5b6f135ad8871e7658.pdf).

3.1 Extension 1 — Context Injection with CLAUDE.md

CLAUDE.md is a configuration file where you accumulate "prerequisite knowledge for Claude Code to understand a given codebase," organized per repository or directory. Anthropic employees write coding standards, test commands, deployment procedures, and past failure patterns into a shared team CLAUDE.md, maintaining a state where Claude Code can immediately grasp context when starting a new task. This alone significantly improves Claude Code's response quality and is rated as the highest-ROI first move.

3.2 Extension 2 — Automating Pre/Post Processing with Hooks

Hooks are a feature for inserting processing at each Claude Code event — before and after tool execution, at session start, and so on. Employees use hooks to enforce lint before commits, add confirmation dialogs before production deployments, and trigger warning notifications when certain files are edited — structurally reducing the risk of Claude Code behaving unexpectedly. Hooks function as guardrails that mechanically constrain "what Claude Code as an AI is and isn't allowed to do."

Here is a minimal hook configuration example that enforces lint before a commit. Adding this to .claude/settings.json will automatically run lint when Claude Code attempts to execute a commit command.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -q \"git commit\" && npm run lint || true'"
          }
        ]
      }
    ]
  }
}

3.3 Extension 3 — Reusing Repetitive Tasks with Skills

Skills are a mechanism for packaging specific workflows and having Claude Code invoke them. For example, by defining repetitive tasks like "create a PR," "generate release notes," or "aggregate data" as Skills, you no longer need to rewrite prompts every time. Within Anthropic, each team maintains a registry of shared Skills so that new members can immediately adopt best practices from the source. A key feature is that they function as a repository for accumulated organizational knowledge.

3.4 Extension 4 — Integrating External Capabilities with Plugins

Plugins are extensions that provide Claude Code with integrations to external services and tools, often implemented as MCP (Model Context Protocol) servers. Employees connect Slack, Linear, GitHub, internal databases, internal APIs, and more as Plugins, creating an environment where Claude Code can directly access these resources. The result is a "complete within a single conversation without switching tools" experience, dramatically reducing the cost of context switching.

3.5 Extension 5 — Background Execution of Long-Running Tasks with Managed Agents

Managed Agents are a mechanism that allows Claude Code to execute long-running tasks in the background. Employees use Managed Agents for refactoring, improving test coverage, large data migrations, and parallel processing of multiple PRs, adopting a working style where they hand off tasks to agents and continue with other work themselves. Within Anthropic, a style of "one person directing multiple agents in parallel" is becoming the norm, and the ceiling on productivity itself is being pushed upward.

4. Three Operational Patterns — CLAUDE.md / Hooks / Supervisory Model

How to Read This vs. Chapter 3: In Chapter 3, we explained the 5 features themselves — CLAUDE.md, Hooks, Skills, etc. In this Chapter 4, we reframe those same features as "patterns for sustained team operation." Understanding both the features (What) and the operations (How) lets you see all the way through to long-term adoption after initial rollout.

Alongside the 5 extension features, the playbook also emphasizes "operational patterns." These are not individual features but rather templates showing "how a team should approach Claude Code" by combining multiple features. Here we introduce in order the 3 patterns validated within Anthropic. None of them require a perfect start — the standard route presented is to introduce the minimal configuration to your team first, then refine it through actual operation (source: https://claude.com/blog/how-anthropic-teams-use-claude-code).

4.1 Pattern A — Team-Shared Rules Centered on CLAUDE.md

The first operational pattern is the approach of consolidating rules that every team member should read into CLAUDE.md. Coding standards, test commands, deployment procedures, review criteria, and past failure cases are written into CLAUDE.md and maintained by everyone through code review. At Anthropic, CLAUDE.md is positioned as "the AI version of the team handbook" and serves a dual role as onboarding material for new members.

4.2 Pattern B — Safety Guardrails Using Hooks

The second pattern uses hooks to establish the team's minimum safety baseline. Examples include: inserting a mandatory confirmation prompt before every production deployment, triggering warnings when certain files (like production configuration) are edited, and enforcing lint before commits. Within Anthropic, hooks are positioned not as "a mechanism for not trusting AI" but as "guardrails for AI and humans to run safely in tandem" — an important conceptual shift in operational philosophy.

4.3 Pattern C — Leveraging the Supervisory Model

The third pattern is a hierarchical structure where a powerful model (Opus) supervises the output of weaker models (Sonnet, etc.), or a review process where humans supervise agents. Within Anthropic, configurations where Opus supervises multiple Sonnet agents are beginning to emerge, attracting attention as a new design pattern that achieves both cost efficiency and quality. The role of humans as final approvers who can intervene is maintained, keeping accountability clearly defined.

5. Three Practical Steps Engineers Can Start Today

The content introduced so far consists of internal Anthropic case studies, but for engineers in other organizations who want to replicate them in practice, translation is needed to account for differences in time zones, language, existing tool stacks, and organizational culture. This section, drawing on editorial experience, presents 3 steps in order for bringing the playbook into your organization at minimum cost. Each step is broken down to a granularity conscious of "starting with one thing today," with the primary goal of lowering the barrier to a first attempt.

Step 1: Write Minimal Rules in CLAUDE.md

The first step is creating a CLAUDE.md. However, rather than trying to write perfect content right away, start by writing just the following 3 minimal items:

1. Explicitly state at the top that responses may be written in your team's preferred language
2. Fix time notation to your local timezone and include it in commit messages as well
3. Write just 2–3 lines covering your main test and lint commands

Here is a minimal CLAUDE.md example you can copy and paste:

# Project Common Rules

Responses and comments may be written in English.

## Time
- All times should be written in the local timezone
- Standardize commit message timestamps to the same timezone

## Commands
- Run tests: `npm test`
- Run lint: `npm run lint`
- Check build: `npm run build`

This alone will produce a noticeable improvement in Claude Code's response quality. For the first commit, prioritize "just commit it" over completeness, and gradually add to it while operating in practice — that is the realistic way forward.

Step 2: Ease In with Just One Hook

The second step is attempting to introduce just one hook. The recommended first hook is either an auto-formatting hook for commit messages or a confirmation hook before production deployment. By not adding both at once and sticking to just one, you minimize the rollback cost if the hook behaves unexpectedly.

Here is a minimal hook configuration you can copy and paste into .claude/settings.json. It adds just one hook that displays a warning when you attempt to edit a file containing production or prod.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'echo \"$CLAUDE_TOOL_INPUT_FILE_PATH\" | grep -qiE \"prod|production\" && echo \"⚠️  You are about to edit a production file. Is this intentional?\" || true'"
          }
        ]
      }
    ]
  }
}

After running it for a week and confirming its effectiveness, safely expand by adding one more hook at a time.

Step 3: Try the Supervisory Model on Just One Task

The third step is trying the Opus supervisory model on just one task. The recommended first attempt is either a review of a large-scale refactoring or a diff summary of multiple PRs. Run it on just one task with the goal of measuring cost-effectiveness, and compare the quality of Opus's judgment against the cost difference from a Sonnet-based execution. Once you've confirmed an acceptable ROI, you'll be in a position to decide whether to incorporate it into regular operations.

Sources

• How Anthropic teams use Claude Code — Anthropic official blog (published May 12–13, 2026)
• Anthropic Official Playbook Full PDF — 30+ pages
• Anthropic Just Dropped Their Claude Code Playbook (Here's What Changed) — English explainer video (published May 15, 2026, SEO score 9)
• How Claude Code Works — Supplementary video (published May 14, 2026, diagram of the agentic loop)