claude-cli — How Boris Uses Claude Code

How Boris Cherny Uses Claude Code

Boris created Claude Code at Anthropic. When asked how he uses it, he shared 13 practical tips from his daily workflow. His setup is "surprisingly vanilla" — proof that CC works great out of the box.

@bcherny's original thread

Click the tabs above to explore each tip →

or use ← → arrow keys

Run 5 Claudes in Parallel

Boris runs 5 instances of Claude Code simultaneously in his terminal using 5 separate git checkouts of the same repo. He numbers his tabs 1-5 for easy reference and uses system notifications to know when any Claude needs input.

Key detail

                        Each tab runs in its own git checkout, so Claude can make changes in parallel without conflicts. Configure iTerm2 notifications to know when any Claude needs attention.

~/repo-1 $ # Tab 1: Working on feature
~/repo-2 $ # Tab 2: Running tests
~/repo-3 $ # Tab 3: Code review
~/repo-4 $ # Tab 4: Debugging
~/repo-5 $ # Tab 5: Documentation
                    

View original post

Parallel Web and Mobile Sessions

Beyond the terminal, Boris runs 5-10 additional sessions on claude.ai/code. He fluidly hands off between local and web using the & command or --teleport flag.

He also kicks off sessions from his phone via the Claude iOS app in the morning, then picks them up on his computer later.

Key commands
& — Background a session
--teleport — Switch contexts between local and web
                    

View original post

Opus 4.5 with Thinking for Everything

Boris uses Opus 4.5 with thinking mode for every task. His reasoning:

Why Opus over Sonnet

                        "It's the best coding model I've ever used, and even though it's bigger & 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."

The takeaway: less steering + better tool use = faster overall results, even with a larger model.

View original post

Shared CLAUDE.md Documentation

The team shares a single CLAUDE.md file for the Claude Code repo, checked into git. The whole team contributes multiple times a week.

Key practice

                        "Anytime we see Claude do something incorrectly we add it to the CLAUDE.md, so Claude knows not to do it next time."

claude-cli $ cat CLAUDE.md
# Development Workflow

**Always use `bun`, not `npm`.**

# 1. Make changes
# 2. Typecheck (fast)
bun run typecheck

# 3. Run tests
bun run test -- -t "test name"    # Single suite
bun run test:file -- "glob"       # Specific files

# 4. Lint before committing
bun run lint:file -- "file1.ts"   # Specific files
bun run lint                      # All files

# 5. Before creating PR
bun run lint:claude && bun run test
                    

View original post

@.claude in Code Reviews

During code review, Boris tags @.claude on PRs to add learnings to the CLAUDE.md as part of the PR itself.

They use the Claude Code GitHub Action (/install-github-action) for this. Boris calls it their version of "Compounding Engineering" — inspired by Dan Shipper's concept.

// Example PR comment:
nit: use a string literal, not ts enum

@claude add to CLAUDE.md to never use enums,
always prefer literal unions
                    

Result

                        Claude automatically updates the CLAUDE.md and commits: "Prefer `type` over `interface`; **never use `enum`** (use string literal unions instead)"

View original post

Start in Plan Mode

Most sessions start in Plan mode (shift+tab twice). Boris iterates on the plan with Claude until it's solid, then switches to auto-accept mode.

The workflow

                        Plan mode → Refine plan → Auto-accept edits → Claude 1-shots it

> i want to improve progress notification
  rendering for skills. can you make it look
  and feel a bit more like subagent progress?

▮▮ plan mode on (shift+tab to cycle)
                    

"A good plan is really important to avoid issues down the line."

View original post

Slash Commands for Inner Loops

Boris uses slash commands for workflows he does many times a day. This saves repeated prompting, and Claude can use them too.

Commands are checked into git under .claude/commands/ and shared with the team.

> /commit-push-pr 

  /commit-push-pr     Commit, push, and open a PR

Power feature

                        Slash commands can include inline Bash to pre-compute info (like git status) for quick execution without extra model calls.

View original post

Subagents for Common Workflows

Boris thinks of subagents as automations for the most common PR workflows:

▼ .claude ▼ agents ↓ build-validator.md ↓ code-architect.md ↓ code-simplifier.md ↓ oncall-guide.md ↓ verify-app.md

Examples
code-simplifier — Cleans up code after Claude finishes
verify-app — Detailed instructions for end-to-end testing
                    

View original post

PostToolUse Hooks for Formatting

The team uses a PostToolUse hook to auto-format Claude's code. While Claude generates well-formatted code 90% of the time, the hook catches edge cases to prevent CI failures.

"PostToolUse": [ { "matcher": "Write|Edit", "hooks": [ { "type": "command", "command": "bun run format || true" } ] } ]

View original post

Pre-Allow Safe Permissions

Instead of --dangerously-skip-permissions, Boris uses /permissions to pre-allow common safe commands. Most are shared in .claude/settings.json.

> /permissions

Permissions: Allow  Ask  Deny  Workspace

Claude Code won't ask before using allowed tools.

↑ 12.  Bash(bq query:*)
  13.  Bash(bun run build:*)
  14.  Bash(bun run lint:file:*)
  15.  Bash(bun run test:*)
  16.  Bash(bun run test:file:*)
  17.  Bash(bun run typecheck:*)
  18.  Bash(bun test:*)
  19.  Bash(cc:*)
  20.  Bash(comm:*)
> 21.  Bash(find:*)
                    

View original post

Tool Integrations

Claude Code uses all of Boris's tools autonomously:

Searches and posts to Slack (via MCP server)
Runs BigQuery queries with bq CLI
Grabs error logs from Sentry

claude-cli-2 $ cat .mcp.json
{
  "mcpServers": {
    "slack": {
      "type": "http",
      "url": "https://slack.mcp.anthropic.com/mcp"
    }
  }
}
                    

View original post

Handle Long-Running Tasks

For very long-running tasks, Boris ensures Claude can work uninterrupted:

Options
(a) Prompt Claude to verify with a background agent when done
(b) Use an agent Stop hook for deterministic checks
(c) Use the "ralph-wiggum" plugin (community idea by @GeoffreyHuntley)
                    

For sandboxed environments, he'll use --permission-mode=dontAsk or --dangerously-skip-permissions to avoid blocks.

* Reticulating... (1d 2h 47m · ↓ 2.4m tokens · thinking)

>

View original post

The Most Important Tip: Verification

This is Boris's #1 tip:

Key insight

                        "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."

For his own changes to claude.ai/code, Claude uses the Claude Chrome extension to open a browser, test UI changes, and iterate until it works perfectly.

Verification varies by domain: Bash commands, test suites, simulators, browser testing, etc. The key is giving Claude a way to close the feedback loop.

Takeaway

                        Invest in domain-specific verification for optimal performance. Claude tests every single change Boris lands to claude.ai/code.

View original post

claude-cli connected

opus-4.5 · thinking