Video summary

Practical Tips on How to use ClaudeCode By Boris Cherny

Main summary

Key takeaways

Technology

Technological concepts & product features (Claude Code / “Quad Code”)

  • Agentic coding (not autocomplete): Claude Code is positioned as a fully agentic assistant that can build features, write entire functions/files, and fix bugs—rather than completing code line-by-line.
  • IDE/tool-agnostic workflow: Works across any IDE and any terminal/environment:
    • Local execution
    • Remote SSH
    • Tmux
    • Various IDEs (VS Code, Xcode, JetBrains, etc.) without changing the workflow.
  • Local code Q&A (no indexing / no training):
    • Performs “code base Q&A” by exploring the local repository.
    • No remote database indexing; code stays local.
    • No uploading for training and no indices to set up.
    • Startup is immediate: no waiting for indexing.
  • Multimodal support: Claude Code is described as fully multimodal in-terminal:
    • Drag-and-drop images
    • Provide file paths
    • Copy/paste images
    • Used for tasks like implementing against mocks (e.g., with a Puppeteer server) to enable iteration.
  • Git-aware understanding:
    • Can analyze how code is used by finding instantiation patterns and real usage examples.
    • Can interpret Git history (e.g., why a function has many args or oddly named params) by examining commits, authorship, context, and linked issues.
    • Can fetch GitHub issues for context (via web fetching).
  • Tool orchestration & extensibility:
    • Claude Code uses a small set of built-in tools (editing files, searching, running bash).
    • It can also use external tools via:
      • Bash tools (custom CLIs)
      • MCP tools/servers
    • Encourages plugging in team tooling so it can execute on your behalf when working in a new codebase.
  • Feedback-driven iteration workflows:
    • If configured with ways to verify outputs (unit tests, integration tests, Puppeteer screenshots, iOS simulator screenshots), Claude Code can iterate automatically to improve results over multiple cycles.
  • Context management via “quad.md” and hierarchy:
    • quad.md in the project root is automatically loaded each session.
    • Supports multiple scopes:
      • Shared project/team quad.md (recommended to check into source control)
      • Personal/local quad.md not checked in
      • Nested quad.md pulled in based on directories
      • Enterprise-root configuration (company-wide defaults)
    • Also supports:
      • slash commands (e.g., .quad slash commands, in home dir or repo)
      • @mention files to pull them into context on demand
    • Emphasis: tune context carefully; too much context wastes tokens and can hurt performance.
  • Permissions & safety model for shell commands:
    • Implementation difficulty highlighted: making bash commands safe at scale.
    • Uses read-only vs mutating command separation, static analysis, and a tiered allow/block permission system (to reduce risk while maintaining usability).
  • Operational key bindings / interaction modes (practical UX):
    • Shift+Tab: enable auto-accept edits mode (edits auto-apply; bash commands still require approval).
    • # remember: instruct it to remember something; stored into quad.md automatically.
    • ! bash mode: run a local bash command; command+output enters context for next turn.
    • Esc: safely stop Claude Code mid-action and adjust; also escape twice to navigate history.
    • resume / –continue: resume previous sessions.
    • Ctrl+R: show the entire output Claude Code sees (useful for more visibility).
  • SDK / CLI usage (“Claude Code SDK” via -P):
    • The SDK is identical to what the product uses.
    • Described like a Unix utility: run quad-p with a prompt and allowed tools, specifying output format (e.g., JSON or streaming JSON).
    • Intended for automation in CI, incident response, and pipelines.
    • Supports piping/combining with shell tools (e.g., piping status into jq).
    • Example data sources: GCP buckets, logs, Sentry CLI, etc.

Guides / tutorials / recommended workflows (explicit “how to”)

  1. Installation / setup path

    • Requires Node.js.
    • Run terminal setup (enables Shift+Enter for new lines).
    • Use {slash} theme for light/dark/daltonize themes.
    • Install a GitHub app to @mention Claude Code on GitHub issues/PRs.
    • Customize allowed tools so you’re not repeatedly prompted.
    • Optional: use macOS dictation to speak prompts (dictation key twice).

  2. Onboarding workflow (best starting point)

    • Start with code base Q&A, not advanced editing or fancy tooling.
    • Use Q&A to learn prompt boundaries and when approvals/interactive mode are needed.
    • Claimed impact at Anthropic: onboarding dropped from 2–3 weeks to ~2–3 days by using Claude Code for codebase questions.

  3. Editing workflow progression

    • After Q&A comfort, move to editing.
    • Agent behavior: if you say what you want, it can chain tools itself (edit files → search → run commands).
    • Recommended pattern: ask it to brainstorm/plan first and request approval before writing code, especially for large features.

  4. Git workflow shorthand

    • “Commit push PR” approach: Claude Code can interpret it to make commits, push branches, and open GitHub PRs without manual details (and it consults git history/logs).

  5. Advanced: team tools + verification/iteration

    • Add team bash and MCP tools so it can operate like a teammate.
    • Provide testing/verification tools so it can iterate toward correct outputs (e.g., unit tests, screenshot-based checks).

  6. Context tuning strategy

    • Use quad.md for shared context and tool lists.
    • Keep it short and include only high-value, reusable knowledge (common commands, style guide, core files, architectural decisions).
    • Use nested quad.md where appropriate.
    • Consider slash commands and @ file mentions for on-demand context.

Reviews / analysis / claims (what’s emphasized)

  • No indexing + local-only code is presented as a major advantage: no waiting, no upload, no training on your code, and no remote database.
  • Better onboarding efficiency is claimed via code base Q&A (weeks → days).
  • Iteration with feedback tools is highlighted as a key technique to reach near-perfect results in practice.
  • Power-user parallelism: advanced usage involves SSH/tmux, multiple sessions per repo, and techniques like git worktrees.

Main speakers / sources

  • Boris Cherny (Anthropic) — creator of Claude Code (“Quad Code” as spoken in the subtitles).

Original video