Sign in Subscribe
claude-code Featured

How Boris Cherny Uses Claude Code: All 57 Tips From the Creator

Anatoliy Kolodkin

• 8 min read

Boris Cherny created Claude Code as a side project at Anthropic in September 2024. He's spent years as a Principal Engineer building developer tools, and it shows in how he actually uses his own creation. Between January and February 2026, he shared his complete workflow in three detailed X threads — 57 tips total — covering everything from parallel sessions to verification loops to customization hooks.

This is the full breakdown, organized for maximum usefulness.

The Creator's Philosophy: No Single Right Way

Before diving in, Boris's framing matters: "There is no one correct way to use Claude Code — we intentionally build it in a way that you can use it, customize it, and hack it however you like." His own setup is "surprisingly vanilla." Take what works for you.

Part 1: Boris's Personal Workflow (January 2026)

1. Run 5 Parallel Sessions in Terminal

Boris keeps 5 instances of Claude Code running simultaneously in numbered terminal tabs (1–5). Each tab runs in its own separate git checkout of the same repo, so Claude can make changes in parallel without conflicts. He uses system notifications (iTerm2) to know when any session needs input.

~/repo-1 $
~/repo-2 $
~/repo-3 $
~/repo-4 $
~/repo-5 $

2. Bridge Terminal and Browser Sessions

Beyond the terminal, Boris runs 5–10 additional sessions on claude.ai/code. He moves work fluidly between local and web using:

  • & — background a terminal session
  • --teleport — move context between local and web

He also starts lightweight sessions from his iPhone in the morning, then picks them up on desktop later in the day.

3. Always Use Opus with Thinking Mode

Boris uses Claude Opus 4.5 with thinking mode for every coding task — even though it's slower per token. His reasoning: "It's the best coding model I've ever used. 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."

Less steering + better tool use = faster results overall, despite higher latency.

4. Treat CLAUDE.md as a Living Document

The entire Claude Code team shares a single CLAUDE.md committed to git. Team members update it multiple times per week. Every time Claude does something incorrectly, they add it to CLAUDE.md so it doesn't happen again.

What belongs in CLAUDE.md:

  • Repeated mistakes Claude makes
  • Project conventions (commands, test/lint flow, style rules)
  • PR templates and design guidelines

5. Let Claude Update Its Own Rules at Code Review

During code review, Boris tags @.claude on PRs to capture learnings directly into CLAUDE.md. He calls it their version of "Compounding Engineering" — knowledge compounds automatically across every PR.

nit: use a string literal, not ts enum

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

Claude automatically commits: "Prefer type over interface; never use enum (use string literal unions instead)"

6. Start Every Session in Plan Mode

Most sessions begin with Plan Mode (Shift+Tab twice). Boris iterates on the plan with Claude until it's solid, then switches to auto-accept mode. Claude typically 1-shots the implementation from there.

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

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

7. Slash Commands for Daily Workflows

For workflows he runs many times per day, Boris creates slash commands stored in .claude/commands/ (committed to git and shared with the team). Power tip: commands can include inline Bash to pre-compute context like git status, reducing back-and-forth with the model.

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

8. Use Subagents for Common PR Workflows

Boris treats subagents as automations for repeatable patterns in the PR lifecycle:

  • code-simplifier — cleans up code after Claude finishes
  • verify-app — detailed end-to-end testing instructions
  • code-architect, build-validator, oncall-guide

9. PostToolUse Hook for Auto-Formatting

A PostToolUse hook automatically runs the formatter after every file write or edit. Claude's code is well-formatted ~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"
  }]
}]

10. Pre-Allow Safe Commands Instead of Skip-Permissions

Boris almost never uses --dangerously-skip-permissions. Instead, he uses /permissions to pre-allow specific safe commands like bun run build:*, bun run test:*, find:*, etc. These are shared via .claude/settings.json. This eliminates unnecessary permission prompts while keeping real guardrails intact.

Exception: he'll use --dangerously-skip-permissions only for very long-running tasks inside sandboxes.

11. Full MCP Integration for Zero Context-Switching

Claude Code uses all of Boris's tools autonomously:

  • Slack MCP — searches and posts to Slack
  • BigQuery via bq CLI — runs analytics queries inline
  • Sentry — grabs error logs directly
{
  "mcpServers": {
    "slack": {
      "type": "http",
      "url": "https://slack.mcp.anthropic.com/mcp"
    }
  }
}

12. Long-Running Tasks: Don't Block

For tasks that run for hours, Boris has three strategies to keep Claude working uninterrupted:

  • Prompt Claude to verify with a background agent when done
  • Use a Stop hook for deterministic completion checks
  • Use --permission-mode=dontAsk in sandboxed environments

13. 🏆 #1 Tip: Give Claude a Way to Verify Its Work

Boris calls this "probably the most important thing to get great results out of Claude Code." When Claude has a feedback loop to verify its own work, it 2–3x's the quality of the final result.

For Claude Code development itself, Claude uses the Chrome extension to open a browser, test UI changes, and iterate until everything works. The verification method varies by domain — bash commands, test suites, simulators, browser testing — but the key is closing the loop.

"Claude tests every single change I land to claude.ai/code using the Claude Chrome extension. It opens a browser, tests the UI, and iterates until the code works and the UX feels good."

Part 2: Team Tips (January 31, 2026)

Boris's second thread shifted focus from personal workflow to what the Claude Code team had collectively discovered.

1. Git Worktrees Are the #1 Team Unlock

The top team tip: spin up 3–5 git worktrees at once, each with its own Claude session running in parallel. Some engineers name worktrees and set up single-keystroke shell aliases (za, zb, zc). Others keep a dedicated "analysis" worktree just for reading logs and running BigQuery queries.

$ git worktree add .claude/worktrees/my-worktree origin/main
$ cd .claude/worktrees/my-worktree && claude

2. Two-Claude Planning: One Writes, One Reviews

One team pattern: have one Claude draft the plan, then spin up a second Claude to review it as a staff engineer before execution begins. Treat planning as adversarial, not collaborative.

And when things go sideways mid-task? Stop pushing forward. Switch back to Plan Mode and re-plan — including re-planning the verification steps.

3. Make Claude Write Its Own Rules

After every correction, end your message with: "Update your CLAUDE.md so you don't make that mistake again." Boris: "Claude is eerily good at writing rules for itself."

One team engineer maintains a notes directory per task/project (updated after every PR) and points CLAUDE.md at it. Ruthlessly iterate on CLAUDE.md until the mistake rate measurably drops.

4. Skills as Institutional Knowledge

If you do something more than once a day, turn it into a skill or slash command. Team examples:

  • /techdebt — run at end of every session to find and kill duplicated code
  • Context dump command — syncs 7 days of Slack, GDrive, Asana, and GitHub into one context
  • Analytics-engineer agents — write dbt models, review code, test changes in dev

Skills committed to git become institutional knowledge. New team members inherit battle-tested workflows immediately.

5. Delegate Broadly, Don't Micromanage

Enable the Slack MCP, paste a bug thread, say "fix." Zero context-switching. Or just: "Go fix the failing CI tests." Don't specify how.

The team also points Claude at Docker logs to troubleshoot distributed systems. It's surprisingly capable at pattern-matching through log noise.

6. Challenge Claude — Don't Just Instruct It

Three power prompting patterns from the team:

  • "Grill me on these changes and don't make a PR until I pass your test." — Make Claude your reviewer
  • "Prove to me this works" — Have Claude diff behavior between main and your feature branch
  • "Knowing everything you know now, scrap this and implement the elegant solution." — Force a second attempt with full context

Treat Claude as a peer who needs to justify their work, not just an assistant who follows instructions.

7. Terminal Setup: Ghostty + Statusline + Voice

The team loves Ghostty for its synchronized rendering, 24-bit color, and proper unicode support. More actionable:

  • Use /statusline to always show context usage and current git branch
  • Color-code and name terminal tabs — one per task/worktree
  • Use voice dictation (fn×2 on macOS) — you speak 3× faster than you type, and prompts get way more detailed as a result

8. Subagents for Context Hygiene

Three subagent patterns:

  • Append "use subagents" to any request where you want Claude to throw more compute at the problem
  • Offload subtasks to subagents to keep your main agent's context window clean and focused
  • Route permission requests to Opus 4.5 via a hook — let it scan for attacks and auto-approve safe ones (use a stronger model as a security gate)

9. Claude Replaces SQL

The team has a BigQuery skill checked into the codebase. Everyone uses it for analytics queries directly in Claude Code. Boris: "Personally, I haven't written a line of SQL in 6+ months."

This generalizes to any database with a CLI, MCP server, or API. The unlock isn't "Claude knows SQL" — it's staying in one context while Claude handles the translation layer.

10. Claude as a Learning Tool

  • Enable "Explanatory" or "Learning" output style in /config to have Claude explain the why behind its changes
  • Have Claude generate an HTML presentation explaining unfamiliar code — it makes surprisingly good slides
  • Ask Claude to draw ASCII diagrams of new protocols and codebases
  • Build a spaced-repetition learning skill: you explain your understanding, Claude asks follow-up questions to fill gaps, stores the results

Part 3: Customization Tips (February 11, 2026)

Terminal & Environment

  • Run /config to set light/dark mode theme to match your terminal
  • Enable system notifications so you can work on other things while Claude runs
  • Use /statusline — always know your context usage before you hit the limit

Permissions Without the Danger Flag

The team's approach to permissions is surgical: use /permissions to pre-allow specific, verified-safe commands rather than blanket skip-all. This gives you the speed benefit without abandoning guardrails. Share the allow-list via .claude/settings.json so the whole team benefits.

Hooks as Your Custom Layer

Hooks are how you make Claude Code truly yours without forking it:

  • PostToolUse hooks for formatting, linting, or any post-edit cleanup
  • Stop hooks for deterministic verification at task completion
  • Permission hooks to route security-sensitive decisions to a stronger model

Skills as Workstations, Not Prompts

The team's philosophy on skills: treat them as workstations — folders with scripts, templates, gotchas, and progressive disclosure — not just instructions. A well-built skill manages Claude's attention budget at runtime and handles edge cases the first prompt never could.

The Underlying Pattern

Read all of Boris's tips as a system — not a list — and a design philosophy emerges:

  1. Parallelization beats optimization — run more sessions, don't try to make one session smarter
  2. Plan deeply, execute cleanly — front-load the thinking; let Claude 1-shot from a solid plan
  3. Claude improves itself — CLAUDE.md and self-updating rules compound over time
  4. Skills are institutional memory — if you repeat it, codify it
  5. Verification closes the loop — 2–3x quality improvement from giving Claude a way to check its own work
  6. Challenge, don't just instruct — treat Claude as a peer who should justify its choices

Boris's own setup may be "surprisingly vanilla," but the philosophy behind it is anything but. The team that built Claude Code uses it at maximum intensity — and the tips reflect that.

Boris Cherny is Head of Claude Code at Anthropic. His original X threads: January personal workflow · January 31 team tips · February 11 customization. All 57 tips are also available as an installable Claude Code skill at howborisusesclaudecode.com.

Want the best Claude Code tips delivered to your inbox? Subscribe to LGTM — a daily digest of what's shipping in AI coding tools.

Sign up for more like this.

Enter your email
Subscribe