Master Claude Code: Pro Tips From Its Creator Boris Cherny

Anthropic cut developer onboarding from two to three weeks down to two to three days, using the tool covered in this tutorial (per Claude Code creator Boris Cherny, May 2025). Claude Code is Anthropic's agentic command-line assistant for software development: the agent reads entire codebases, plans changes, writes and edits files, and runs commands on its own.

This tutorial distills the core practices of Boris Cherny, creator and head of Claude Code at Anthropic (livestream on May 22, 2025, around Anthropic's developer conference "Code with Claude"). Afterward, you'll query your codebase instead of your colleagues, have Claude Code plan before every change, and let it check its own work against tests.

• Claude Code is a fully agentic coding tool that runs in any terminal, any IDE, and over SSH or tmux, with no workflow switch required.
• The most effective way to start is codebase Q&A, not immediate code changes: ask questions first, then let it edit.
• A short, well-maintained CLAUDE.md in the project root is one of the strongest levers for better results. Rule of thumb: keep it under 200 lines.
• Having Claude Code plan before coding (Plan Mode) and giving it a way to check its own work (tests, screenshots) noticeably improves results.
• A lot has shifted technically since the talk, from the installer to the keybindings: the section "What's Changed Since Cherny's Talk (May 2025)" below rounds up the key updates.

What Is Claude Code, and Why a Terminal Agent?

Claude Code differs from classic code-completion tools in its ambition: it isn't built to suggest single lines, but to build entire features, write whole functions and files, and fix bugs on its own.

To do that, the agent combines a deliberately lean set of tools: reading and editing files, running bash commands, searching the code. Claude Code chains these tools into workflows on its own, without needing every single step spelled out.

A core design principle is that Claude Code fits into existing workflows instead of replacing them. The agent runs in any terminal with zero configuration: locally, over remote SSH, or inside a tmux session, a terminal multiplexer that keeps multiple sessions open in parallel. That holds regardless of whether your team uses VS Code, JetBrains IDEs, Xcode, or Vim.

The terminal is no longer the only official interface, though. As of July 2026, Claude Code also runs on four additional surfaces, and the same agentic coding assistant sits behind all of them:

• VS Code extension
• JetBrains plugin
• Standalone desktop app
• Browser at claude.ai/code

This tutorial shows the terminal path throughout: the commands and concepts are identical in the IDE integrations, since the same engine runs behind every surface.

About 80 percent of Anthropic's technical staff use Claude Code every day.

Boris Cherny, Anthropic, May 2025 (internal figure, not an independent survey)

That explains why Claude Code is so uncompromisingly built around a developer's daily workflow: it is the most-used internal tool inside the company that builds it.

Ready in 10 Minutes: First-Time Setup

Setting up Claude Code for the first time takes a few minutes, and it decides whether the tool keeps interrupting you or runs quietly in the background. Below: install it, set up terminal and theme, tune permissions, and optionally connect GitHub.

# Recommended (default since 2026): native installer, no Node.js required
curl -fsSL https://claude.ai/install.sh | bash

# Alternative: via a package manager
brew install --cask claude-code        # macOS
winget install Anthropic.ClaudeCode    # Windows

# npm remains available as an option (Node.js 22 or newer required)

The Best Starting Point: Questions, Not Code

The most effective way to start with Claude Code isn't to write code, it's to query your own codebase. Before you let it edit anything, just ask Claude Code: How does a given class get instantiated? Why does a function take fifteen parameters? What changed in the repository this week?

These questions cost nothing, carry no risk, and show very quickly what the agent can actually do in your specific codebase.

How is the PaymentProcessor class instantiated, and where is it used throughout the codebase?

Why does this function have 15 parameters? Check the git history to see who introduced it and why.

What did I ship this week? Check the git log under my username.

Claude Code doesn't answer questions like this with simple full-text search. For a question like "How is this class used?", the agent typically looks for real instantiation examples in the code and returns an answer you'd expect from a well-maintained wiki page, not from a single search hit.

For git-history questions like "Why is this parameter named so oddly?", Claude Code searches the commit history to find out when and by whom a change was introduced, and which ticket or issue it belonged to.

There's nothing in the system prompt about checking the git history. The model just knows to do it because it's good. If you tell it to use git, it knows how.

Boris Cherny, Anthropic, May 2025

The onboarding cut mentioned at the start traces back to exactly this effect: new hires query the codebase directly instead of interrupting a teammate for every unclear detail.

As long as Claude Code runs locally in the terminal, the agent works directly on your machine: there's no separate search database your code gets uploaded to, and so no indexing wait either.

You install Claude Code and ask your first question right away. What that means for training and privacy in practice differs by account type. The section "What Happens to Your Code? Privacy Today" further down breaks that out in detail.

Plan First, Then Code

Hand Claude Code a big task in one go, say "build this 30,000-line feature", and you'll sometimes get exactly what you wanted on the first try. More often, though, something else happens: the result is technically functional, but it isn't quite what you actually meant. The more reliable path: let Claude Code think before the first line of code gets written.

Concretely, that means letting it explore and brainstorm a bit first, then propose a plan, approving that plan, and only then letting it code. In May 2025, a simple natural-language request was enough for this: "Make a plan before you start coding."

Today there's also a dedicated, official Plan Mode for this: a permission mode that only researches and proposes changes without executing them. Three ways get you there:

• Press Shift+Tab to switch into Plan Mode.
• Prefix a single prompt with /plan.
• Start the session directly with claude --permission-mode plan.

The free-form phrasing still works. The native Plan Mode just makes the flow more reliable and easier to repeat.

The Force Multiplier: Let Claude Check Its Own Work

The single most effective lever for better results is giving Claude Code a way to check its own work. Without a feedback loop, the agent often delivers a usable but not-quite-perfect result on a UI task like "build this interface from this mock".

Give it the ability to check its own output instead, say through unit tests, Puppeteer screenshots, or recordings from the iOS simulator, and it keeps iterating on its own. After two or three passes, it nails the result almost exactly.

Give the model some tool to check its own output. Then it just keeps iterating on its own, and you get a much better result.

Boris Cherny, Anthropic, May 2025

CLAUDE.md: The Project's Memory

The more context Claude Code has about a project, the more accurate its decisions get. A short, well-maintained CLAUDE.md file in the project root is the biggest lever for that: a plain text file that Claude Code automatically reads at the start of every session, before your first prompt. What belongs in it, and how to keep it short, is covered in the workflow below.

Memory Shortcuts and Keybindings

Claude Code is deliberately minimalist, which in the terminal also means useful key combinations aren't self-explanatory. The table below shows the shortcuts currently valid for interactive mode.

Resume a session:

• claude --resume / -r: resumes a specific session, chosen by ID or name. Handy for going back to a particular earlier conversation.
• claude --continue / -c: loads the most recent conversation in the current directory. Handy for a quick pickup after an interruption.

To teach Claude Code something permanently, say that a certain tool should be used differently, a simple natural-language request like "Remember that we use pnpm instead of npm here" is enough today: Claude Code files that away on its own into the right memory file via Auto Memory.

Team Setup: Configure Once, Everyone Benefits

Once several people work with Claude Code in the same repository, configuration that's written once and then used by the whole team pays off. One person invests the setup time, everyone benefits.

You can define recurring workflows as custom commands. Technically, custom slash commands in files under .claude/commands/ still work, but they've been folded into Skills: structured folders with their own metadata. A file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both produce the same /deploy command and work identically. For new team commands, the skill structure is now the recommended path.

You check MCP servers into version control via an .mcp.json file in the project root. The Model Context Protocol is an open standard for connecting external tools and data sources.

Every team member who starts Claude Code in this repository automatically gets offered the same MCP tools, say, a shared Puppeteer server. That lets you run end-to-end tests and screenshot interfaces automatically, without everyone installing the server individually.

Permissions themselves follow a clear order of precedence, from company-wide to personal:

1. Managed Settings (managed-settings.json): company-wide, cannot be overridden by anyone.
2. CLI arguments passed when starting claude.
3. Local project settings (.claude/settings.local.json).
4. Shared project settings (.claude/settings.json).
5. Personal settings (~/.claude/settings.json).

{
  "permissions": {
    "allow": ["Bash", "Edit", "Read"],
    "ask": ["WebFetch"],
    "deny": []
  }
}

Headless: Claude Code as a Unix Utility

With the claude -p flag (or --print), you run any claude command non-interactively (headless): a prompt goes in, an answer comes out, with no interactive session at all. Combined with --output-format text, json, or stream-json, Claude Code turns into a genuine Unix tool you can build into pipelines, scripts, and automation.

# Claude Code as a Unix utility: prompt in, answer out
claude -p "Summarize the most notable changes" --output-format json

# Piping: have it analyze git status directly
git status | claude -p "What stands out to you about this state?" --output-format stream-json

# With a restricted tool selection for CI or incident response
claude -p "Check the latest error messages in the log" --allowedTools Bash

At Anthropic, this exact pattern is used in CI pipelines and in incident response. You pipe logs, error messages, or the output of git status straight into Claude Code and ask it to flag anything notable.

Via --allowedTools, you further restrict which tools an automated run like this can use without asking first.

What was still called the “Claude Code SDK” in May 2025 has officially been the Claude Agent SDK since September 29, 2025. The mechanics have not changed: it still runs on the same engine as Claude Code itself.

Working in Parallel Like the Power Users

A single Claude Code run per terminal tab is enough for many tasks. If you want to push several things forward at once, you need isolation. Otherwise two sessions running at the same time end up overwriting the same files.

Claude Code now offers several native ways to do this, plus the classic approach using multiple checkouts:

• claude --worktree <name> (or -w): automatically creates an isolated git worktree, an additional, parallel working directory of the same repository on its own branch, and starts directly inside it.
• Subagents: self-contained Claude Code instances for sub-tasks within a single session.
• Ctrl+B: move bash commands to the background (see keybindings above).
• Classic approach: multiple manual checkouts of the same repository plus separate tmux or SSH sessions, which is what Anthropic’s power users relied on before. Still works, but it's the original, more cumbersome path.

AI-generated (gpt-image-2)

What Happens to Your Code? Privacy Today

Whether Anthropic trains on your code depends on the account type. At the time of the talk, this was still regulated more uniformly than it is today:

Regardless of training, a second distinction still matters. When Claude Code runs locally in your own terminal, the agent works on your own machine, with no separate search index or persistent external copy of the repository.

Cloud sessions work differently: there, Claude Code clones the repository into an Anthropic-managed virtual machine. Worth knowing before you start one.

What's Changed Since Cherny's Talk (May 2025)

• Installation: the native curl installer is now the default; npm is just an option. Details above in the section "Ready in 10 Minutes: First-Time Setup".
• SDK rename: the Claude Code SDK became the Claude Agent SDK. Details above in the section "Headless: Claude Code as a Unix Utility".
• Memory shortcut: the earlier #-shortcut has been replaced by Auto Memory. Details above in the section "Memory Shortcuts and Keybindings".
• Team commands: slash commands have been folded into Skills. Details above in the section "Team Setup: Configure Once, Everyone Benefits".
• Transcript viewer: the shortcut for it moved from Ctrl+R to Ctrl+O; Ctrl+R is now reverse search in the command history.
• Parallel work: worktrees, subagents, and background tasks now run natively instead of being improvised. Details above in the section "Working in Parallel Like the Power Users".

From Install to First Answer in 25 Minutes

If you want to try out the core practices from this tutorial, you can go from an empty terminal to your first useful answer in about 25 minutes. The two how-tos above cover steps one and two in detail:

1. Install: run the native installer via the curl script (or brew, winget, npm), as shown in the setup chapter above.
2. Create a CLAUDE.md: generate a first draft with /init and trim it down to the essentials.
3. Ask your first question: ask Claude Code about your own codebase, say about a specific class or the git history, instead of letting it change code right away.

Frequently Asked Questions