Article Review: Group 18 — Boris Cherny's Complete Claude Code Tips Collection¶

Articles Reviewed¶

"Boris Cherny's Claude Code Tips Are Now a Skill. Here Is What the Complete Collection Reveals." — Reza Rezvani / Medium (Mar 2026) — Analysis of all 42+ tips from 8 threads (January–March 2026) by the creator of Claude Code, arguing they form a single coherent workflow methodology rather than isolated tips.
howborisusesclaudecode.com — Complete aggregation of all Boris Cherny tips across all threads, organized chronologically.

Key Concepts¶

The Collection as a System¶

The article's central argument: Boris didn't share 42 tips — he shared one workflow, incrementally. Read as a system, the tips reveal a design philosophy organized around four pillars:

Parallelization — Run 5+ Claude instances across git worktrees simultaneously
Plan-first execution — Start every complex task in plan mode, iterate on plan, then 1-shot the implementation
Verification loops — Give Claude a way to verify its work (tests, browser, CLI) for 2-3x quality uplift
Living documentation — CLAUDE.md as a self-healing config that Claude maintains for itself

Thread-by-Thread Highlights (42+ Tips, Jan–Mar 2026)¶

Thread 1 (Jan 2, 13 tips) — Foundations¶

Run 5 Claudes in parallel, numbered tabs, system notifications
Opus 4.5 with thinking for everything (steers less, better tool use = faster despite being larger)
Shared CLAUDE.md checked into git, team contributes multiple times weekly
The most important tip: Verification — "Give Claude a way to verify its work. If Claude has that feedback loop, it will 2-3x the quality of the final result."

Thread 2 (Jan 31, 10 tips) — Team Workflow¶

Git worktrees are the single biggest productivity unlock — 3-5 worktrees at once, each running independent Claude
After every correction: "Update your CLAUDE.md so you don't make that mistake again." Claude is good at writing rules for itself.
Have one Claude write the plan, spin up a second Claude to review it as a staff engineer
"Go fix the failing CI tests" — Claude fixes most bugs by itself with Slack MCP + access to logs

Thread 3 (Feb 11, 12 tips) — Customization¶

Plugins install LSPs, MCPs, skills, agents, custom hooks from marketplace
Custom agents via .claude/agents/*.md with custom name, color, tool set, permissions, model
Pre-approve common permissions via /permissions instead of dangerously skipping
Hooks for routing permission requests to Slack/Opus, nudging continuation, pre/post-processing

Thread 4 (Feb 20, 5 tips) — Worktree Deep Dive¶

claude --worktree for isolation, optional --tmux for background sessions
Subagents now support worktree isolation for parallel batched work
Custom agents can declare isolation: worktree in frontmatter

Thread 5 (Feb 27, 2 tips) — Built-in Skills¶

/simplify — Parallel agents review code for reuse, quality, efficiency in single pass
/batch — Interactive migration planning, parallel execution with dozens of worktree-isolated agents

Thread 6 (Mar 7-10, 3 tips) — Automation¶

/loop — Recurring tasks for up to 3 days unattended ("babysit all my PRs, auto-fix build issues and comments")
Code review agents dispatched on PR open — specialized agents hunt bugs, post inline comments
/btw — Side-chain conversation while Claude works, no context pollution

Thread 7 (Mar 13, 8 tips) — Session Management¶

/effort max — Unlimited reasoning tokens per session
Remote control — spawn new sessions from mobile app connected to local dev environment
Voice mode — hands-free coding via microphone
claude --name and auto session naming after plan mode
PostCompact hook — react to context compression, re-inject critical instructions

Thread 8 (Mar 2026, 4 tips) — Autonomy & Memory¶

Auto mode — classifiers evaluate each action, safe ops auto-approved, risky ones flagged
/schedule — Cloud-based recurring jobs that survive laptop closure
Auto-memory saves preferences/corrections between sessions; auto-dream consolidates and prunes memory

The Four-Pillar Methodology¶

Pillar	Core Practice	Anthropic's Metric
Parallelization	3-5 worktrees + numbered tabs + shell aliases	—
Plan-first	Plan mode → review → 1-shot implementation	—
Verification	Domain-specific feedback loops (tests, browser, CLI)	2-3x quality uplift
Living docs	CLAUDE.md as self-healing config	200% code output/engineer at Anthropic

Mapping to Our Architecture Repo & Claude Code Config¶

What We Already Do Well¶

CLAUDE.md is comprehensive and team-maintained — Our CLAUDE.md is checked into git with rules, patterns, module structure, and enforcement guidance. This directly matches Boris's pillar of "Living Documentation." We're already doing what he recommends.
Slash commands and skills — We have 5 slash commands (/check-boundaries, /new-adr, /new-module, /review-architecture, /divergence-check) and 3 skills (exploring-module, writing-reference-impl, reviewing-architecture). These match Boris's tip about building reusable skills committed to git.
PostToolUse hooks for formatting — Our settings.json has hooks for black formatting checks and core/shell boundary enforcement. This matches Boris's PostToolUse hook pattern exactly.
Session Hygiene section — We already document /btw, /fork, /rewind, context budget management, and the master session pre-warming pattern. These were added from the Group 16 review.
Subagent usage — Our skills use subagents for parallel exploration (e.g., exploring-module launches multiple concurrent agents). This matches Boris's recommendation to use subagents for increased compute while keeping main agent context clean.
Plan mode guidance — Our exploring-module skill uses plan mode for complex explorations. CLAUDE.md's EnterPlanMode guidance aligns with Boris's "start every complex task in plan mode."

Improvements Identified¶

1. HIGH: Add Verification Loops to Skills¶

Boris's single most emphasized tip: "Give Claude a way to verify its work." Our skills currently produce output but don't systematically verify it. This is the highest-leverage improvement.

Specific gaps: - reviewing-architecture produces a review document but doesn't verify findings against actual code (e.g., confirming a boundary violation exists by reading the import) - writing-reference-impl produces a reference doc but doesn't verify that described patterns actually exist in the module's codebase - exploring-module explores deeply but doesn't validate its conclusions

Recommended change: Add a verification step to each skill that spot-checks its own output — read 2-3 specific files to confirm claims before presenting results.

2. MEDIUM: Add "Update CLAUDE.md" Correction Pattern¶

Boris's tip: After every correction, end with "Update your CLAUDE.md so you don't make that mistake again." We don't currently have this feedback loop. When someone corrects Claude during an architecture review, that learning stays in the conversation and dies with the session.

Recommended change: Add to CLAUDE.md Session Hygiene:

When Claude makes a mistake during a session, after fixing it, ask: "Update your CLAUDE.md so you don't make that mistake again." This creates a self-healing documentation loop where corrections compound.

This is conceptually the same as our auto-memory system, but specifically for CLAUDE.md project-level rules that benefit the whole team (vs. user-specific memory).

3. MEDIUM: Document Worktree Pattern for Multi-Module Work¶

Boris identifies worktrees as the "single biggest productivity unlock." Our Session Hygiene section mentions /fork for branching but doesn't mention worktrees for parallel module work.

Use case: When reviewing architecture across multiple modules (e.g., checking how documentloader, documentexporter, and documentextractor all handle checkpoint patterns), spin up 3 worktrees, each exploring one module, then synthesize findings.

Recommended change: Add to Context Hygiene Commands:

--worktree / /worktree — For multi-module architecture work, spin up separate worktrees per module. Each gets its own Claude session with isolated file changes. Combine with --name for easy identification (e.g., claude --worktree --name "loader-review").

4. LOW: Add `/simplify` Mention to Review Workflow¶

Boris's /simplify runs parallel agents reviewing code for reuse, quality, and efficiency. This is directly complementary to our /review-architecture command — architecture review checks patterns and boundaries, while /simplify checks code quality.

Recommended change: Add to Slash Commands table:

After running /review-architecture, consider running /simplify on changed code to catch reuse opportunities and quality issues.

5. LOW: Document PostCompact Hook Opportunity¶

Boris's Thread 7 introduces the PostCompact hook — fires after context compression. For our long architecture exploration sessions that load significant context (patterns, rules, reference implementations), a PostCompact hook could re-inject critical architectural rules that might be lost during compression.

Recommended change: Evaluate adding a PostCompact hook that re-injects the core boundary rules (core/ never imports from shell/) after context compression. This is speculative — only worth implementing if we observe boundary rule violations in post-compaction Claude output.

What We Should NOT Adopt¶

Auto mode — Boris uses auto mode for auto-approving safe operations. For architecture work where we're defining patterns and rules that propagate across all repos, the explicit approval model is correct. We want deliberate reviews, not speed.
Voice mode — Not applicable to architecture documentation work where precision of language matters.
iMessage/remote control — Our architecture repo work is deliberate, laptop-based work. Remote mobile access adds no value here.

Actionable Changes¶

Change	Target	Priority
Add verification loops to skills (spot-check output against actual code)	`.claude/skills/*/SKILL.md`	HIGH
Add "update CLAUDE.md on correction" pattern	`CLAUDE.md` Session Hygiene	MEDIUM
Document worktree pattern for multi-module architecture work	`CLAUDE.md` Context Hygiene Commands	MEDIUM
Add `/simplify` to slash commands guidance	`CLAUDE.md` Slash Commands	LOW
Evaluate PostCompact hook for boundary rule re-injection	`.claude/settings.json`	LOW

Summary¶

Boris Cherny's 42+ tips, read as a system, describe a four-pillar methodology: parallelization (worktrees), plan-first execution, verification loops, and living documentation (CLAUDE.md). Our architecture repo already implements three of these four pillars well — we have comprehensive CLAUDE.md, plan mode usage, and parallel agent patterns. The main gap is systematic verification: our skills produce analysis but don't verify their own output against the actual codebase. Adding verification loops to skills is the highest-leverage improvement. The secondary gap is the "update CLAUDE.md on correction" feedback loop, which would make our project-level documentation self-healing in the same way Boris describes for engineering teams at Anthropic.

Ask the Architecture ×

Ask questions about Nextpoint architecture, patterns, rules, or any module. Powered by Claude Opus 4.6.