Cat Wu + Boris Cherny, Anthropic's AI use case

Founding engineers of Claude Code at Anthropic

Claude Code’s founding engineers explain how Anthropic uses it internally: planning before coding, standardizing team settings, using stop hooks to finish tests, deploying subagents for review, and splitting large migrations into parallel work.

The problem

What was broken before AI

AI coding tools can make teams faster, but they can also create a new kind of mess. A developer may ask for too much at once, approve vague changes, forget to run tests, or let each person configure the tool differently. The result is uneven: one engineer gets great output, another gets chaos, and the team has no shared way to make the agent safer or more reliable.

What changed

What the use case made possible

Inside Anthropic, Claude Code is treated less like a chatbot and more like a tool that needs operating habits. Plan mode gives people a chance to agree on the approach before code changes. Shared settings files keep permissions consistent across a team. Stop hooks can make the model run tests and fix failures before handing control back. Subagents can review work from different angles or divide a migration into smaller pieces.

Why this matters

Why this use case is worth studying

Cat and Boris show that the leap from “AI writes code” to “AI helps a team ship better software” comes from the system around the model. The workflow gets stronger when people define when to plan, what the tool is allowed to touch, when it should keep going, and which smaller agents should check the work. That turns Claude Code from a clever assistant into part of the engineering process.

Use this when

When this pattern applies

Use this pattern when AI coding is starting to work for individuals, but the team needs more consistency and trust. It is especially useful when people are asking Claude Code to handle bigger changes, review code, run repetitive migrations, or work inside a shared codebase where mistakes can affect other people.

Exponential Builder analysis

Planning is a team control surface.

Plan mode matters because it moves judgment earlier, before the agent has filled the repo with plausible edits. The leverage comes from giving humans a cheap moment to correct assumptions, file scope, and verification strategy.

Reliability comes from defaults, hooks, and boundaries.

Anthropic’s pattern treats Claude Code as part of the engineering environment: shared permissions, blocked commands, test-running stop hooks, and clear handoff rules. That reduces the gap between one person’s careful workflow and another person’s risky one.

Subagents work best when the work naturally separates.

Review passes, migration chunks, and challenge passes are good fits because each agent can hold a narrow brief. Throwing more agents at vague work would only multiply ambiguity; the useful move is decomposition first, parallelism second.

Who this is for

Best fit

Engineering teams adopting AI coding tools

Tech leads setting team defaults

Developers using Claude Code on larger tasks

Teams doing repetitive code migrations

Teams that need safer agent permissions

Organizations trying to standardize AI coding habits across a codebase

What to avoid

Mistakes and warnings

Where this pattern can go wrong if you copy it too literally.

Do not expect one prompt to solve a complex task without planning.

Avoid letting every teammate configure the agent differently if the team needs consistent behavior.

Do not skip verification just because the code looks plausible.

Watch for false positives from AI code review; use follow-up checks before acting on every finding.

Use subagents where tasks can be separated cleanly, not as a default for every problem.

Public workflow preview

The shape of the workflow

A high-level look at how the use case works, with the reusable pattern made clear.

Plan before touching code

For complex work, Claude Code first maps out the approach so the developer can correct direction before edits begin.

Standardize the defaults

Teams can use shared settings so common commands are pre-approved and risky ones are blocked for everyone.

Make the agent finish the job

Stop hooks can run checks after a task and send failures back to Claude instead of stopping too early.

Split review into smaller jobs

Subagents can look for different problems, such as style issues, history conflicts, or obvious bugs.

Use agents for repetitive migrations

Bigger changes become easier when the main agent creates a task list and subagents work through pieces in parallel.

Copy the pattern

The reusable idea

Pattern in one sentence

AI coding becomes more reliable when the team designs the working environment around the agent: planning first, shared defaults, automated checks, and smaller review passes.

Reusable idea

The useful lesson is that AI coding gets better when the team designs the working environment around it. Before asking for big changes, decide how the model should plan, what it can touch, how it should prove the work is done, and who or what should review it. The same model behaves very differently when it has a process instead of a blank instruction box.

Steal this workflow

Use this mini operating procedure for one repo before rolling AI coding practices across a team:

Pick one recurring task type, such as a bug fix, refactor, review, or migration.

Require a plan before edits: expected files, proposed steps, risks, and verification method.

Review the plan and correct scope before allowing code changes.

Create shared team settings for commands the agent can run and commands it should never run.

Add a stop hook that runs the relevant test or lint command when the task is complete.

If checks fail, route the failure back to the agent and have it continue before handing back control.

For review, run separate passes for style, project history, obvious bugs, and edge cases.

Add a second challenge pass to remove weak or false-positive findings.

Keep human review as the merge gate, and update the process whenever the same AI mistake appears twice.

Suggested prompt

“Before changing code, create a plan. List the files you expect to touch, the steps you will take, the risks or assumptions, and how you will verify the change. Wait for approval before editing. After the change, run the relevant tests or checks. If anything fails, inspect the failure, fix it, and rerun the checks before handing the work back. For review, use separate passes for style, project history, obvious bugs, and edge cases, then challenge the findings and remove likely false positives.”

Field notes

Get new AI use cases in your inbox

A short weekly note on how real people are using AI to save time, make money, build tools, and run their lives.

Related use cases

Keep exploring nearby systems.

Browse all

Prototyping & DesignMarketing & Content+1

Jascha Kaykas-Wolff + Alexandra Roberts

Co-creators of Eleanore; Kaykas-Wolff is a former Mozilla CMO and Roberts is an artist at Eleanore

AI-assisted beverage brand buildout workflow spanning brand identity, market strategy, web design, vendor outreach, packaging, and operational planning.

ChatGPTCustom GPTsClaude+9

Use case

View use case

Prototyping & DesignCoding & Engineering

Terry Lin

Product manager and AI-assisted app builder at Cooper's Corner

Terry Lin built Cooper's Corner, a voice-powered Apple Watch and iPhone fitness app, by combining low-tech index-card prototyping with a structured AI coding workflow in Cursor and Xcode.

CursorXcodeLinear+6

Use case

View use case

Coding & EngineeringMarketing & Content

Lee Robinson

Head of AI Education at Cursor

Lee Robinson uses Cursor as a quality-control agent for code and ChatGPT as a style editor for sharper, less generic writing.

CursorChatGPTTypeScript+1

Use case

View use case