Boris Cherny’s Claude Code Tips: 42 Tips from Claude Code’s Creator

Bottom Line Up Front

Boris Cherny is the creator of Claude Code, Anthropic’s terminal-based AI coding agent. His personal workflow reveals something unexpected: the person who built the tool uses a “surprisingly vanilla” setup — 5 numbered terminal tabs, system notifications, and a disciplined approach to parallel work. His 42 tips, published openly at howborisusesclaudecode.com, cover everything from git worktrees for running 3-5 simultaneous coding sessions to using Plan Mode for 1-shot complex tasks to CLAUDE.md as persistent memory. The single most important tip from the person who literally built the tool: give Claude a way to verify its work — that alone will 2-3x your output quality. If you are using Claude Code without these patterns, you are leaving massive productivity on the table.

Key Takeaways

• Parallel sessions multiply your output — Boris runs 5 simultaneous Claude Code instances using git worktrees with shell aliases (za, zb, zc) to navigate between them instantly
• Plan Mode prevents wasted iterations — start complex tasks with shift+tab twice, iterate on the plan until solid, then switch to auto-accept for flawless execution
• CLAUDE.md is compounding institutional memory — a single file checked into git that the whole team updates whenever Claude makes a mistake, so it never repeats the error
• Hooks automate the boring stuff — PostToolUse hooks auto-format code after every generation, and permission routing hooks send approval requests to Opus for security scanning
• Subagents handle repeatable workflows — agents like code-simplifier, verify-app, and build-validator live in .claude/agents/ and can be invoked by appending “use subagents”
• Verification is the #1 quality multiplier — Boris says giving Claude a feedback loop (test suites, browser testing, CI) will 2-3x the quality of every result
• There is no one correct way — the creator himself emphasizes experimentation over prescription, proving mastery comes from adapting the tool to your workflow

Who Is Boris Cherny?

Boris Cherny is a software engineer at Anthropic and the creator of Claude Code. Before building the tool that has redefined how developers interact with AI, Cherny authored Programming TypeScript (O’Reilly, 2019), one of the definitive references for TypeScript developers worldwide. His background spans type systems, developer tooling, and programming language design — experience that directly shaped Claude Code’s architecture. At Anthropic, he leads the team responsible for Claude Code’s development, making his personal tips the most authoritative source available on how to use the tool effectively. When the person who designed every feature shares how they actually use it daily, that is worth paying attention to.

What makes Cherny’s approach particularly valuable is its restraint. He does not use an exotic setup. He does not rely on obscure hacks. His workflow is described on his own site as “surprisingly vanilla” — and that is the point. Claude Code is powerful enough out of the box that the creator himself needs only disciplined fundamentals to achieve peak productivity. The 42 tips he shares publicly at howborisusesclaudecode.com represent battle-tested patterns from someone who uses Claude Code 8+ hours per day to build Claude Code itself — a recursive loop of AI-assisted development.

Boris Cherny’s Terminal Setup: Surprisingly Vanilla

Before diving into specific tips, understanding Boris’s physical setup provides context for everything that follows. He runs 5 numbered terminal tabs simultaneously, each connected to a separate git checkout of the codebase. He uses iTerm2 (though the Claude Code team loves Ghostty for its synchronized rendering, 24-bit color, and proper Unicode support) with system notifications enabled so he knows when any of the 5 sessions needs his input.

Beyond the terminal tabs, Boris also manages 5-10 parallel sessions on claude.ai/code, using the & background flag and --teleport to switch contexts. He even starts morning sessions from the Claude iOS app during his commute, then picks them up on his desktop later. This is not a power user flexing — it is the natural workflow of someone who treats Claude Code sessions the way a project manager treats Slack threads: multiple conversations running in parallel, each making progress independently, with the human jumping in only when needed.

The status line feature (/statusline) keeps him oriented across all these sessions, showing context usage, git branch, active model, working directory, and remaining cost at a glance. Voice dictation via macOS’s built-in fn-fn shortcut is another staple — Boris notes that speaking is 3x faster than typing and yields more detailed prompts because people naturally provide more context when talking than when typing.

Tip Category 1: Git Worktrees for Parallel Sessions

The single biggest force multiplier in Boris Cherny’s workflow is running 3-5 Claude Code sessions in parallel using git worktrees. Unlike separate git clones (which duplicate the entire repository), worktrees share a single .git directory while maintaining independent working directories. This means each worktree has its own branch, its own staged changes, and its own Claude Code session — all without the disk overhead of full clones.

The Anthropic team creates shell aliases for instant navigation between worktrees:

# Shell aliases for worktree navigation
alias za='cd ~/code/project-worktree-a'
alias zb='cd ~/code/project-worktree-b'
alias zc='cd ~/code/project-worktree-c'

With these aliases in place, switching between parallel coding sessions is as fast as typing two characters. Tab 1 might have Claude refactoring a database layer. Tab 2 could be building a new API endpoint. Tab 3 handles writing tests. Each session operates on its own branch in its own worktree, completely isolated from the others. There is zero risk of merge conflicts between sessions because they are working on separate branches from the start.

Some team members maintain a dedicated “analysis” worktree exclusively for non-coding tasks — reading logs, running BigQuery queries, and investigating production issues. This keeps analytical work separated from active development, preventing accidental file changes in the wrong context. If you are currently running only one Claude Code session at a time, this single change — adopting worktrees for parallel execution — could triple your throughput immediately.

The practical ceiling depends on your hardware and the complexity of each task. Boris regularly runs 5 terminal sessions plus 5-10 web sessions, but for most developers, starting with 3 worktrees is the sweet spot. Create them once, set up your aliases, and you will never go back to single-session development. For a complete walkthrough of Claude Code’s coding capabilities, see our full guide.

Tip Category 2: Plan Mode for 1-Shot Complex Tasks

Most of Boris Cherny’s complex coding sessions start in Plan Mode. Accessed by pressing shift+tab twice, Plan Mode tells Claude Code to analyze the problem and produce a detailed execution plan before writing any code. This is not a suggestion — Boris explicitly states that “a good plan is really important to avoid issues down the line.”

The workflow follows a clear progression:

1. Enter Plan Mode (shift+tab twice)
2. Describe the task in detail — the more specific your prompt, the better the plan
3. Iterate on the plan with Claude — ask questions, challenge assumptions, request alternatives
4. Switch to auto-accept once the plan is solid
5. Claude executes the plan with minimal human intervention

The critical insight is step 3. Most developers skip straight to execution, treating Claude Code like an autocomplete engine. Boris treats it like a staff engineer — you would not let a junior developer start coding a complex feature without reviewing their approach first. The same discipline applies to Claude Code. Spending 5 minutes refining the plan saves 30 minutes of backtracking and rework.

Some members of the Anthropic team take this even further: they use one Claude session to write the plan, then feed that plan to a second Claude session acting as a “staff engineer reviewer.” This two-Claude approach catches architectural issues that a single session might miss because the reviewer brings fresh context without the anchoring bias of the session that generated the plan. For more on effective Claude prompting strategies, see our dedicated guide.

Boris also recommends pushing Claude for elegance during planning. One of his go-to prompts is: “Knowing everything you know now, scrap this and implement the elegant solution.” This forces Claude to step back from incremental patches and consider whether the entire approach should change. Another technique is challenging Claude directly: “Grill me on these changes and don’t make a PR until I pass your test.” This flips the dynamic so Claude is evaluating your reasoning, not the other way around.

Tip Category 3: CLAUDE.md as Persistent Memory

CLAUDE.md is a markdown file that lives in your project root and gets loaded automatically at the start of every Claude Code session. Boris describes it as institutional memory for your codebase — and his quote about it is remarkably candid: “Claude is eerily good at writing rules for itself.”

At Anthropic, a single CLAUDE.md file is checked into git and shared across the entire team. Multiple engineers contribute to it weekly. The operating principle is simple: anytime someone sees Claude do something incorrectly, they add a rule to CLAUDE.md so it never happens again. Over weeks and months, this file becomes a growing repository of project-specific knowledge that makes every Claude Code session smarter than the last.

Example entries from real CLAUDE.md files include:

# CLAUDE.md

## Package Management
- Always use `bun`, not `npm` or `yarn`

## TypeScript Conventions
- Prefer `type` over `interface`
- Never use `enum` — use string literal unions instead
- Always use explicit return types on exported functions

## Testing
- Run `bun test` before committing
- Use `describe/it` blocks, not `test()`

## PR Guidelines
- Keep PRs under 400 lines when possible
- Always include a test plan in PR descriptions

The compounding effect is what makes CLAUDE.md transformative. Each rule added today prevents the same mistake in every future session, for every team member. Boris calls this “Compounding Engineering” — a concept inspired by Dan Shipper. The team even has a GitHub Actions integration where tagging @.claude on a PR automatically updates CLAUDE.md. When a code reviewer spots Claude making a pattern mistake, they tag the PR, and the CLAUDE.md file gets a new rule without anyone opening an editor.

For individual developers, the takeaway is immediate: create a CLAUDE.md file in your project root today. Start with 5 rules based on your project’s conventions. Every time Claude does something you need to correct, add another rule. Within a month, your Claude Code sessions will feel like working with a colleague who has read your entire style guide, understands your architecture decisions, and remembers every correction you have ever given. For more on getting started with Claude’s capabilities, see our complete guide to using Claude AI.

Tip Category 4: Hooks for Automated Quality Control

Hooks are deterministic automation scripts that run at specific points in the Claude Code workflow. Boris uses them extensively, and two patterns stand out as essential: PostToolUse auto-formatting and permission routing to Opus.

PostToolUse Hook: Auto-Format on Every Edit

Claude Code generates well-formatted code approximately 90% of the time. The PostToolUse hook catches the other 10%. After Claude makes any file edit, the hook automatically runs your project’s formatter (Prettier, Black, gofmt, or whatever your stack uses). This ensures that every line of code Claude writes matches your project’s formatting standards without you ever thinking about it.

The practical benefit is preventing CI failures. Without the hook, that remaining 10% of formatting inconsistencies would trigger linting errors in your continuous integration pipeline, requiring you to either fix them manually or ask Claude to fix what it just wrote. The hook eliminates this entire category of friction. Code goes from Claude’s output to your formatter to your working directory in a single step.

Permission Routing Hook: Opus as Security Scanner

Instead of using the dangerous --dangerously-skip-permissions flag that bypasses all safety checks, Boris routes permission requests through a hook that sends them to Opus 4.5 for analysis. When Claude Code wants to execute a potentially risky command, the hook intercepts the request, feeds it to Opus, and Opus evaluates whether the command is safe to auto-approve.

This creates an AI-reviewing-AI security layer. Opus scans for common attack patterns — command injection, file system destruction, network exfiltration — and either approves or blocks the request. The result is that safe commands run without interrupting your flow, while genuinely dangerous operations still get flagged for human review. It is a middle ground between the constant permission prompts of the default mode and the zero-safety approach of skipping permissions entirely.

Stop Hooks for Long-Running Tasks

For extended tasks where Claude needs to work uninterrupted — large refactors, multi-file migrations, comprehensive test writing — Stop hooks add deterministic checks that keep Claude working until the job meets specific criteria. Instead of Claude stopping prematurely and asking “should I continue?”, the Stop hook evaluates whether the exit conditions are met and sends Claude back to work if they are not. This is particularly powerful when combined with the /loop command, which can schedule recurring tasks up to 3 days unattended.

Tip Category 5: Subagents and Slash Commands

Boris organizes reusable workflows into two categories: slash commands in .claude/commands/ and subagents in .claude/agents/. Both are checked into git so the entire team benefits.

Subagents for Complex Workflows

Subagents are specialized Claude instances that handle specific categories of work. The Anthropic team maintains several that automate common PR workflows:

• code-simplifier — Reviews completed code for reuse opportunities, quality improvements, and efficiency gains
• verify-app — Runs detailed end-to-end testing instructions against the application
• build-validator — Ensures the build passes all checks before a PR is created
• code-architect — Evaluates architectural decisions and suggests structural improvements
• oncall-guide — Provides context for on-call engineers investigating production issues

To invoke subagents in a Claude Code session, Boris’s tip is straightforward: append “use subagents” to your prompt. This signals Claude Code to spawn specialized sub-instances that handle discrete parts of the task independently. Each subagent operates in its own context, tests its own work, and reports results back to the parent session. The /simplify command takes this further by dispatching parallel agents that review code for reuse, quality, and efficiency improvements simultaneously.

Slash Commands for Repeated Prompts

Slash commands save you from re-typing common prompts. They live in .claude/commands/ as markdown files and can include inline Bash to pre-compute information (like git status or environment variables) before the model processes them. This means the command runs instantly without burning extra model calls on gathering context.

Notable built-in commands that Boris highlights include /batch for parallel code migrations where each agent tests independently and creates its own PR, /btw for asking questions mid-task without interrupting Claude’s flow, and /effort max for activating deeper reasoning mode when a problem requires burning more tokens. The team also uses /schedule for cloud-based recurring jobs that persist beyond laptop closure — unlike /loop, which runs locally and stops when your machine sleeps.

Tip Category 6: Verification — The #1 Quality Multiplier

If you take only one tip from Boris Cherny’s entire collection, make it this one. In his own words: “Probably the most important thing to get great results out of Claude Code — give Claude a way to verify its work. If Claude has that feedback loop, it will 2-3x the quality of the final result.”

Verification means giving Claude Code access to a feedback mechanism that confirms whether its output actually works. The specific mechanism depends on your domain:

• Web development — Claude uses the Chrome extension to test UI changes visually and iterates until the output matches the design
• Backend development — Run the test suite after every change so Claude sees failures immediately and self-corrects
• Data engineering — Execute queries against staging data to verify transformations produce expected results
• Mobile development — Use simulators to verify UI rendering and interaction behavior
• Infrastructure — Run terraform plan or dry-run deployments to validate changes before applying

The pattern is universal: tight feedback loops produce better code. When Claude can see the result of its work, it self-corrects in real time instead of producing a best guess and hoping it works. This is the same principle that makes test-driven development effective for human programmers — the test is a contract that verifies the implementation. Claude Code uses that same contract, but it iterates faster because it can read test output, diagnose failures, and fix them in seconds rather than minutes.

Boris’s team at Anthropic uses this pattern with Claude Code’s own development. Claude uses the Chrome extension to test UI changes on claude.ai/code, iterating until the visual output is pixel-perfect. This is literally AI building AI tooling, verified by AI testing — the most advanced feedback loop in production software development today.

Boris Cherny’s Philosophy: No One Correct Way

Across all 42 tips, one meta-pattern emerges: Boris Cherny does not prescribe a single “correct” way to use Claude Code. His philosophy is explicitly anti-dogmatic. The tool is designed to be customizable at every level — keybindings (/keybindings), output styles, themes (/config), spinner verbs, terminal settings (/terminal-setup), and 37 settings plus 84 environment variables. The expectation is that every developer will adapt Claude Code to their own workflow rather than conforming to a template.

This philosophy extends to model selection. Boris personally uses Opus 4.5 with thinking mode exclusively, explaining: “It’s the best coding model I’ve ever used, and even though it’s bigger and slower than Sonnet, since you have to steer it less and it’s better at tool use, it is almost always faster than using a smaller model in the end.” But he does not insist everyone do the same. The /config menu lets you switch between models based on the complexity of your current task.

His customization philosophy also shows in learning modes. The /config menu includes “Explanatory” and “Learning” output styles that make Claude explain the why behind its changes, not just the what. For developers learning a new codebase or a new language, this turns every Claude Code session into a mentoring session. The tool does not just write code — it teaches you why that code is the right approach.

The deeper lesson is that mastery of Claude Code is not about memorizing commands. It is about understanding the principles — parallel execution, persistent memory, automated verification, feedback loops — and then assembling them into a workflow that matches how you think and work. Boris’s 42 tips are a menu, not a recipe. For a broader look at AI-assisted coding workflows, see our complete vibe coding guide.

Tool Integrations Boris Relies On

Beyond the core Claude Code features, Boris highlights several integrations that his team uses daily:

• Slack MCP — Claude Code can search and post Slack messages directly, configured in .mcp.json. This means Claude can check team conversations for context without you copy-pasting messages.
• BigQuery CLI — Boris notes that he has not personally written a line of SQL in over 6 months. Claude runs bq queries for metrics analysis directly in the terminal.
• Sentry — Claude fetches error logs directly from Sentry, correlating production errors with the code that caused them without requiring you to switch between windows.
• Permissions via settings.json — Instead of skipping permissions entirely, the team pre-allows safe commands using wildcard syntax like "Bash(bun run *)" or "Edit(/docs**)" in a shared .claude/settings.json committed to the repository.

These integrations share a common theme: they keep Claude Code as the single interface. Rather than switching between Slack, a SQL client, an error tracker, and the terminal, everything flows through Claude Code. The human stays in one place, and Claude handles the context-switching across tools.

New and Advanced Features

Boris’s guide also covers several cutting-edge capabilities that push Claude Code beyond basic coding assistance:

• Remote control — Spawn new sessions from your phone while connected to your local development environment. Start a refactoring task from the couch and check progress from your desk.
• Code review agents — Automatically dispatched on pull requests, these specialized agents catch real bugs with domain-specific review patterns, not just style violations.
• Voice mode — Available in Claude Desktop and Cowork, speak to Claude instead of typing. Combined with the iOS app, this enables coding conversations during commutes.
• iMessage plugin — Text Claude like a contact from any Apple device. Ask quick questions without opening a terminal.
• Auto-Memory and Auto-Dream — Persistent memory with automatic cleanup via subagents. Claude Code remembers context across sessions and prunes outdated information automatically.
• /schedule — Cloud-based recurring jobs that survive laptop restarts. Unlike /loop (which runs locally), scheduled tasks execute in the cloud on a cron schedule.

Applying Boris’s Tips: The STACK Framework

If you want a structured way to implement Boris Cherny’s advice, the STACK framework from Beginners in AI maps directly to his workflow patterns:

• S — Situation: Define your project context, constraints, and goals. This maps to Boris’s Plan Mode — spend time upfront defining the problem before writing code.
• T — Task: Break the work into discrete, testable chunks. This maps to his parallel worktree approach — each tab handles one task.
• A — Action: Execute with Claude Code using the right tools (hooks, subagents, slash commands). Let automation handle the repetitive parts.
• C — Check: Verify the output using feedback loops. This is Boris’s #1 tip — always give Claude a way to check its own work.
• K — Knowledge: Capture what you learned in CLAUDE.md. This is Compounding Engineering — every session makes the next one better.

The STACK framework is part of the Beginners in AI Frameworks Bundle, which includes 5 proven frameworks for getting better results from any AI tool. You can get the full bundle for $19:

Quick Reference: All 42 Tips at a Glance

Here is a condensed overview of Boris Cherny’s key tip categories for quick reference:

Category	Key Tip	Impact
Parallel Execution	Git worktrees with za/zb/zc aliases	3-5x throughput multiplier
Planning	Plan Mode (shift+tab twice) before execution	Eliminates rework on complex tasks
Memory	CLAUDE.md checked into git, updated by team	Compounding quality improvement
Automation	PostToolUse hooks for auto-formatting	Zero CI formatting failures
Security	Route permissions to Opus instead of skipping	Safe automation without risk
Subagents	Specialized agents in .claude/agents/	Repeatable quality workflows
Verification	Give Claude feedback loops (tests, browsers)	2-3x quality improvement
Model Choice	Opus 4.5 with thinking for less steering	Faster net results despite slower model
Voice	fn-fn dictation for 3x faster prompts	More detailed, natural instructions
Integrations	Slack MCP, BigQuery, Sentry in-terminal	Single-interface workflow

Free Resource: Claude Essentials Guide

If you are just getting started with Claude Code or want to sharpen your fundamentals before implementing Boris’s advanced tips, download our Claude Essentials guide. It covers the core workflows, prompting patterns, and setup steps that make everything in this article possible:

Sources

• How Boris Uses Claude Code — Boris Cherny’s official guide with all 42+ tips
• Anthropic — Grokipedia — Background on Claude’s creator company and AI safety mission
• Claude Code Documentation — Anthropic — Official documentation for Claude Code features and configuration

Related Articles

• Claude Code: The Complete Beginner’s Guide
• Claude for Coding: How to Use AI for Software Development
• How to Use Claude AI: Complete Guide
• Best Claude Prompts: Proven Strategies for Better Results
• Vibe Coding Guide: AI-Assisted Development Workflows

Frequently Asked Questions

Who is Boris Cherny and why should I trust his Claude Code tips?

Boris Cherny is a software engineer at Anthropic and the creator of Claude Code. He also authored Programming TypeScript (O’Reilly, 2019). His tips come from building the tool and using it 8+ hours daily to develop Claude Code itself. When the person who designed every feature shares their personal workflow, it represents the most authoritative source available. His 42 tips are published openly at howborisusesclaudecode.com and reflect battle-tested patterns, not theoretical advice.

What are git worktrees and how does Boris use them with Claude Code?

Git worktrees are a built-in Git feature that lets you check out multiple branches simultaneously in separate directories, all sharing a single .git directory. Boris uses worktrees to run 3-5 parallel Claude Code sessions — each in its own worktree on its own branch — with shell aliases (za, zb, zc) for instant navigation. This multiplies throughput because each session works independently without risking merge conflicts. Some team members also maintain dedicated “analysis” worktrees for non-coding tasks like reading logs and running queries.

What is CLAUDE.md and how does it make Claude Code smarter over time?

CLAUDE.md is a markdown file in your project root that loads automatically at the start of every Claude Code session. It contains project-specific rules, coding conventions, and corrections. At Anthropic, the team adds a new rule every time they see Claude make a mistake, so the same error never happens again. Over time, this file becomes institutional memory that makes every session more accurate. Boris calls this “Compounding Engineering” and says “Claude is eerily good at writing rules for itself.” The team even has a GitHub Actions bot that updates CLAUDE.md when reviewers tag @.claude on pull requests.

How do Claude Code hooks work for auto-formatting and permissions?

Hooks are deterministic scripts that trigger at specific points in the Claude Code workflow. The PostToolUse hook runs your formatter (Prettier, Black, etc.) automatically after every code edit, catching the approximately 10% of cases where Claude’s output does not perfectly match your project’s style. The permission routing hook intercepts potentially risky commands and sends them to Opus 4.5 for security analysis, creating an AI-reviewing-AI layer that auto-approves safe operations while flagging genuinely dangerous ones. This replaces the all-or-nothing choice between constant permission prompts and the –dangerously-skip-permissions flag.

What is Boris Cherny’s single most important Claude Code tip?

Verification. In Boris’s own words: “Probably the most important thing to get great results out of Claude Code — give Claude a way to verify its work. If Claude has that feedback loop, it will 2-3x the quality of the final result.” This means connecting Claude Code to test suites, browser testing, simulators, or any mechanism that shows Claude whether its output actually works. When Claude can see the result of its changes, it self-corrects in real time instead of producing a best guess. This single principle — tight feedback loops — is the difference between Claude Code producing decent code and producing excellent code.

---

Stay ahead of the curve with weekly AI tips, tool reviews, and tutorials.