Source: paddo.dev/blog/claude-code-team-tips Date: 2026-02-01
Commentary on Boris Cherny's 10 tips from the Claude Code team at Anthropic. Boris is the creator/head of Claude Code. Source thread: x.com/bcherny/status/2017742741636321619
Parallelisation is the top unlock — 3–5 git worktrees with separate Claude sessions. Shell aliases to hop between them. Dedicated "analysis" worktree for logs and queries. Separate directories mean separate contexts — no cross-contamination.
Re-plan when stuck — switch back to Plan Mode rather than pushing through. One engineer uses a second Claude to review the plan "as a staff engineer" before execution. Plan mode is for recovery, not just setup.
Claude writes its own rules — after every correction, prompt: "Update your CLAUDE.md so you don't make that mistake again." The team ruthlessly edits CLAUDE.md, iterating until mistake rates measurably drop. One engineer maintains a notes directory per task, updated after every PR, with CLAUDE.md pointing at it.
Skills as institutional knowledge — codify repeated workflows as skills checked into git. Examples: /techdebt (find and kill duplicated code), context dump (syncs 7 days of Slack, GDrive, Asana, GitHub into one context), analytics agents (dbt models, review, test).
Claude fixes its own bugs — paste a bug thread via Slack MCP, say "fix." Point Claude at docker logs for distributed systems. Trust Claude to figure out the path; give it the problem, not the solution.
Prompting as provocation — challenge Claude as a peer. "Grill me on these changes and don't make a PR until I pass your test." "Prove to me this works." After mediocre fixes: "Knowing everything you know now, scrap this and implement the elegant solution."
Terminal setup matters — /statusline for context usage and git branch. Colour-coded tabs per worktree. Voice dictation for prompts (fn×2 on macOS) — you speak 3× faster than you type, and prompts get more detailed.
Subagents for context hygiene — offload tasks to subagents to keep the main agent's context window clean. Route permission requests to Opus 4.5 via a hook — use a more capable model as a security gate, not as the primary worker.
Claude replaces SQL — BigQuery skill checked into the codebase. Everyone uses it for analytics queries directly in Claude Code. Boris says he hasn't written SQL in 6+ months. The unlock: stay in one context while Claude handles the translation layer.
Learning with Claude — enable "Explanatory" or "Learning" output style in /config. Generate HTML presentations explaining unfamiliar code. ASCII diagrams of protocols and codebases. Spaced-repetition learning skills.
The consistency across all ten tips is in the underlying philosophy, not specific techniques:
Most of these tips have structural equivalents in the PCE:
| Cherny/Anthropic practice | PCE equivalent | Difference |
|---|---|---|
| Parallelisation (multiple sessions) | Multiple coding agent sessions (core, frontend, backend, deployment) plus task system for workspace operations | Same practice; boundaries blur in practice |
| Re-plan when stuck | Conversational remit adjustment (e.g. task 136→137) | Ad hoc vs. observed and documented |
| CLAUDE.md as mistake log | Practice notes directory referenced from CLAUDE.md | Single consolidated file vs. distributed, linked documentation |
| Skills as institutional knowledge | Prompts, practice notes, operations guide | Slash commands vs. document store |
| Claude fixes its own bugs | Curator sweeps, self-continuation | Ad hoc vs. pipeline with verification |
| Prompting as provocation | Adversarial pipeline (Corroborator, Critic) | Per-session prompting vs. structural roles |
| Terminal setup | Relevant for engineering department (coding agents) | Same domain |
| Subagents for context hygiene | Delegate expensive operations to tasks | Same principle, different mechanism |
| Claude replaces SQL | Document search and grep tools | Stay in one context for queries |
| Learning with Claude | Observations directory, reference notes | Session-local vs. persistent workspace |
Note on visibility: The Consul has limited visibility into engineering practice — it sees the artefacts (commits, design notes, bug reports) but not the process (session count, coordination, what gets abandoned). This is by design: the information partition means the Consul doesn't need to see how the code gets written, only what was decided and what was built. The engineering sessions operate below the visibility boundary, same principle as the Critic not seeing the Composer's source material.
Documentation-first vs. code-first: Cherny's workflow is code-centric — plan in Plan Mode, execute, review the PR. The design lives in the session and the PR description. The PCE practice is documentation-first: design documents are written before code, coding agents read the design document rather than reverse-engineering intent from the codebase, and the design document is updated after implementation to reflect what was actually built. This creates a feedback loop between design and implementation that drives the process and saves time and money — agents aren't spending tokens reverse-engineering architecture from source code. See documentation-first development.
Implicit institutional memory: Cherny's tips focus on CLAUDE.md as the memory layer, but Anthropic's real institutional knowledge presumably lives in GitHub issues, PR discussions, Slack, and internal documents — the same places it lives in any software organisation. The "context dump" skill (tip 4) that syncs 7 days of Slack, GDrive, Asana, and GitHub into one context is revealing: it exists because that knowledge is scattered and must be manually assembled for each session. How effectively this corpus is searchable by their coding agents, and how available it is without human curation, is unclear. The PCE's document store with full-text and semantic search is an attempt to make this assembly automatic rather than manual.
Key architectural difference: cross-context communication. Cherny's team treats each session as isolated — separate worktrees, separate contexts, no cross-contamination. Knowledge stays trapped in the session that produced it. The only bridge is CLAUDE.md, which is manually maintained and kept as a single consolidated file.
The PCE workspace is a shared memory that all agents and sessions read and write. The Curator enriches a document in one task; the Composer reads it in another. The Consul writes an observation; a future session picks it up through orientation. Practice notes written today steer task dispatch tomorrow. No session is isolated because the workspace persists across all of them.
This is the core argument of Artificial Organisations (arXiv:2602.13275): organisational structure — shared documents, roles, information partitions — enables collective behaviour that isolated agents cannot achieve. Cherny's team approximates it with conventions and a shared file. The PCE makes it structural.
Boris's team CLAUDE.md is ~2.5k tokens. Checked into git. The whole team contributes multiple times a week. The rule: when Claude does something wrong, add it so it doesn't repeat. During code review, Boris tags @.claude on coworkers' PRs to add learnings to CLAUDE.md.
Boris runs 10–15 concurrent sessions: 5 in terminal, 5–10 in browser, plus mobile. He exclusively uses Opus 4.5 with thinking for all coding. Cherny notes that 10–20% of sessions are abandoned due to unexpected scenarios or edge cases beyond Claude's current capabilities.