Claude-Code-Workflow-Guide

Tips from the Claude Code Team

These tips come directly from Boris Cherny (Claude Code creator) and Thariq (Anthropic Claude Code team), compiled from their public posts in 2026.

Boris Cherny — Creator Tips

On Parallelism

  1. Run 5 local worktree sessions + 5–10 cloud sessions simultaneously for maximum throughput
  2. Each worktree is an independent context — no contamination between workstreams
  3. Parallelism isn’t about running the same task faster — it’s about running different tasks simultaneously
  4. Use tmux to manage multiple local sessions without losing track
  5. Don’t parallelize tasks with shared state — sequence those instead

On Model Selection

  1. Use Opus with extended thinking for coding tasks, even though it’s slower per response
  2. The metric is task completion speed, not token speed — fewer correction turns = faster overall
  3. Opus requires less steering and excels at tool use, making it net faster for complex tasks
  4. Switch to Sonnet for well-defined implementation grind — no reasoning needed for boilerplate
  5. Switch mid-session: /model opus when stuck, /model sonnet for grinding

On Verification

  1. Verification loops are the single most impactful improvement you can make
  2. 2–3x quality improvement from automated test running after every edit
  3. Claude with test feedback > Claude without test feedback by a massive margin
  4. Set up PostToolUse hooks to auto-run tests — don’t ask Claude to run them manually
  5. The verification loop should close automatically, not require a separate prompt

On CLAUDE.md

  1. After every session where Claude makes a mistake, add a rule to CLAUDE.md
  2. A shared CLAUDE.md in version control ensures the whole team benefits from every lesson
  3. CLAUDE.md should get better with every session — it’s a living document, not a one-time setup
  4. Short and focused beats long and comprehensive — Claude processes top of file most attentively
  5. Test your CLAUDE.md by asking Claude what rules apply — if it can’t answer, fix the file

On Automation

  1. If you’ve typed a workflow more than twice, make it a slash command
  2. /loop 5m /babysit-prs handles PR queue management without manual attention
  3. Automated bug fixing (Claude watching failing tests and fixing them) works well for isolated test failures
  4. Use --bare flag for scripted/automated Claude invocations — up to 10x startup speed
  5. Lifecycle hooks (SessionStart, PreToolUse) enable consistent context loading per project

On Voice

  1. Primary coding via voice produces better prompts than typing
  2. Spoken prompts naturally include more context (you’d feel odd speaking just “fix auth”)
  3. Voice reduces the friction of writing detailed prompts
  4. Better prompts = fewer correction turns = better final output
  5. Try /voice for complex prompting tasks, even if you type for implementation

On Mobile and Cross-Device

  1. iOS/Android app lets you review PRs and approve plans without your laptop
  2. /teleport and /remote-control sync sessions across devices
  3. Long-running research tasks run on cloud sessions while you’re mobile
  4. Start something before a meeting, check on it from your phone
  5. Async plan approval: Claude proposes, you approve from phone, Claude continues

Thariq (Anthropic) — Platform Tips

On Context Management

  1. Context rot starts around 300–400k tokens — don’t wait until you’re out of context to act
  2. “Just because you haven’t run out of context doesn’t mean you shouldn’t start fresh”
  3. Rewind over correcting: jump back before the mistake, re-prompt with lessons learned
  4. /compact maintains momentum; /clear gives you control — know which you need
  5. Subagents garbage-collect exploration noise — use them whenever research would pollute main context

On the 5 Decision Points

  1. After every turn: choose consciously between Continue / Rewind / Compact / Clear / Subagent
  2. Most engineers default to Continue when they should Rewind — breaks the habit
  3. The cost of re-establishing context (2-3 min) < cost of degraded context (rest of session)
  4. When in doubt: clear and start fresh. You lose less than you think.
  5. The decision point mindset makes you a better Claude Code user than any single tip

On Skills

  1. Don’t include info Claude already knows — focus on your system’s specific behavior
  2. The Gotchas section is the most valuable part of any skill — built from real failures
  3. Skills are folders with progressive disclosure, not monolithic markdown files
  4. Give Claude goals and constraints, not rigid steps — goals survive environment changes
  5. Measure skill effectiveness via usage logs — undertriggering = wrong description

On the 9 Skill Types

  1. Library & API Reference skills fill the gap between training cutoff and your internal tools
  2. Product Verification skills encode user flows that must work — not just tests
  3. Data Fetching skills let Claude query your actual data during debugging
  4. Business Process skills automate workflows involving multiple systems
  5. Code Scaffolding skills encode your team’s exact patterns — eliminate “follow the pattern in X”
  6. Code Quality skills encode the standards linters can’t catch
  7. CI/CD skills handle deployment workflows with judgment calls
  8. Runbook skills make incident response actionable (not just readable)
  9. Infrastructure skills provide safe guardrails for engineers doing rare infra tasks

On Session Strategy

  1. Session-per-phase for large features — each phase gets fresh context
  2. Use git commits as cheap context restoration points
  3. Handoff notes between sessions prevent losing progress
  4. New task + related concern = consider whether to continue or start fresh
  5. The most common mistake: extending sessions too long and accepting degraded quality

On Team Patterns

  1. Skills that benefit the whole team belong in the repo — commit them
  2. Usage logging identifies which skills are most valuable to your team
  3. Organic curation: skills move to “official” status after demonstrating traction
  4. Build team skills from real workflows, not theoretical ones
  5. A skill that nobody uses is dead weight — prune regularly
  6. The best skills are built from “we always explain this to new engineers” moments

Synthesis: The Most Impactful 10

If you could only do 10 things from this list:

  1. Verification loops — PostToolUse hook running tests automatically (Boris #1)
  2. Rewind over correct — break the correction habit immediately (Thariq)
  3. CLAUDE.md → living document — update after every mistake (Boris)
  4. Plan mode first — every non-trivial task (Boris)
  5. Session-per-phase — isolate research, planning, execution (Thariq)
  6. Commit slash commands — automate any repeated workflow (Boris)
  7. Subagents for research — keep main context clean (Thariq)
  8. Model for the task — Opus for decisions, Sonnet for grinding (Boris)
  9. Skill Gotchas section — encode every failure into the skill (Thariq)
  10. Compact with hints — don’t compact blindly, tell Claude what matters (Thariq)