Claude Code Practical Tips: A Complete Guide from Code Q&A to Parallel Workflows

Boris, a member of Anthropic's technical team and core developer of Claude Code, recently gave a hands-on presentation packed with practical insights, systematically covering Claude Code's usage tips, configuration methods, and advanced techniques. This article distills the key content from that session to help developers quickly get up to speed with this AI programming assistant.

What is Claude Code?

Claude Code is an AI programming assistant from Anthropic. Unlike traditional tools that complete code line by line or write a few lines at a time, it possesses full agentic capabilities — it can build complete features, write functions and files, and even fix entire bugs in one go.

Traditional AI coding tools like early versions of GitHub Copilot primarily used a "completion mode," predicting the next few lines of code based on cursor position. The agentic mode represents a paradigm shift in AI programming assistants: the model no longer passively waits for instructions but can autonomously plan tasks, invoke tool chains, execute multi-step operations, and adjust strategies based on intermediate results. This capability relies on the "Tool Use" mechanism of large language models — during reasoning, the model can decide to invoke external tools like file editors, terminal commands, and search engines, forming a "think → act → observe → think again" loop. This aligns with the ReAct (Reasoning + Acting) framework, evolving AI from a code snippet generator into an intelligent agent capable of understanding the full project context and autonomously completing complex development tasks.

Its greatest strength is seamless compatibility with existing toolchains. Whether you use VS Code, Xcode, JetBrains IDEs, or even Vim, Claude Code integrates without friction. It runs in the terminal and supports local environments, remote SSH, Tmux, and various other scenarios — truly achieving zero migration cost.

Installation is extremely simple, requiring just a single command, with the only prerequisite being Node.js.

First Steps: Start with Code Q&A

For users new to Claude Code, Boris's first piece of advice is: don't rush into writing code — start by asking questions about your codebase.

At Anthropic internally, this has become the standard technical onboarding process. On their first day, new hires simply download and configure Claude Code, then immediately start asking questions about the codebase — understanding code structure, function purposes, how classes are instantiated, and more. This approach has dramatically shortened technical onboarding from the typical two to three weeks down to two to three days.

Here are several practical Q&A scenarios:

• Code comprehension: Ask directly "how exactly is this code used" or "how do I instantiate this class." Claude Code won't simply do a text search — it digs deep into actual usage examples and provides detailed answers akin to consulting a wiki.
• Git history tracing: Encounter those functions with 15 parameters and bizarre names? Have Claude Code look through the Git history — it'll help you trace the origins of parameters, who added them, and which issues they're linked to.
• GitHub Issue queries: Fetches issues and related context via web scraping.
• Weekly report generation: Boris asks every Monday "what did I ship this week," and Claude Code automatically reviews Git logs, identifies the username, and generates a clear delivery summary.

It's worth emphasizing that Claude Code's Q&A functionality requires no index building whatsoever. Code runs entirely locally, is never uploaded to any remote database, and is never used for model training. Zero configuration, ready to use on download. This stands in stark contrast to many AI coding tools that require pre-built vector indexes or code uploads to the cloud — Claude Code relies on the model's own reasoning capabilities and real-time file reading to understand codebases, both safeguarding data privacy and eliminating the overhead of index construction and maintenance.

Advanced Usage: Having Claude Code Write Code for You

Once you're comfortable with the Q&A functionality, you can try having Claude Code directly edit code. As an agentic application, Claude Code is equipped with a minimal toolset — editing files, running Bash commands, and searching files — but it can flexibly combine these tools to first explore code, brainstorm, and then complete modifications.

Plan First, Code Later: The Key to Avoiding Rework

Boris particularly emphasized one critical habit: before having Claude Code write code, have it create a plan first.

He frequently sees users immediately asking Claude Code to implement massive 3000-line features, only to get output that completely misses expectations. A better approach is to first say "please brainstorm and create a plan for me to review — start writing code only after I approve." This doesn't require enabling any special mode; just tell it in natural language. The principle behind this strategy aligns with the "design before code" principle in software engineering: when task complexity exceeds a certain threshold, upfront architectural planning significantly reduces the probability of later rework. For AI agents, the planning phase also helps the model establish a clear task decomposition structure within the context window, giving each subsequent execution step clear objectives and constraints.

Letting Claude Code Self-Iterate

As long as you can let Claude Code verify its own work, output quality improves dramatically. Specific approaches include:

• Having it write and run unit tests
• Automated screenshots via Puppeteer or iOS Simulator for UI verification
• Giving it a design mockup, having it build a web interface and iterate two or three times

Puppeteer is a Node.js library developed by Google that provides programmatic control over Chrome/Chromium browsers, including page navigation, DOM manipulation, screenshots, and PDF generation. In Claude Code's workflow, Puppeteer plays a critical role as a "visual feedback loop": after Claude Code completes frontend code modifications, it can use Puppeteer to automatically launch a browser, render the page, and take a screenshot, then feed the screenshot back to the model as multimodal input so the model can "see" the results of its modifications. This visual verification mechanism compensates for the limitations of pure text-based code review, enabling AI to perform the "code → preview → adjust" iterative cycle just like human developers, significantly improving UI development accuracy.

The core trick is giving it a tool it can use for feedback and self-checking, so it can iterate on its own and ultimately produce higher-quality results.

Commits and PRs in One Go

Claude Code can understand instructions like "commit, push, and create a PR." It automatically reviews the code, examines Git history, figures out the commit format, and then correctly executes the entire workflow. These capabilities aren't taught through system prompts — the model inherently possesses them.

Context Management: CLAUDE.md and the Memory System

To get better performance from Claude Code, the key is providing sufficient context. Boris introduced multiple ways to bring in context:

CLAUDE.md File Hierarchy Explained

• Project-level CLAUDE.md: Placed in the project root directory, automatically loaded at the start of every session. Recommended to commit to version control and share with the team for "write once, reuse by all."
• Local CLAUDE.md: For personal use only, no need to commit to version control.
• Nested subdirectory CLAUDE.md: Can be placed in any subdirectory and auto-loads when Claude operates within that directory.
• Enterprise-level CLAUDE.md: Shared across all codebases for unified team standards management.

CLAUDE.md files typically contain: common Bash commands, coding style guidelines, architectural decisions, important file paths, etc. Boris recommends keeping them as concise as possible — overly long files not only consume the context window but often produce diminishing returns.

Here it's important to understand the technical meaning of the context window: it's the maximum number of tokens a large language model can process in a single inference pass. Claude series models have an industry-leading 200K token context window, but even so, careful budgeting is needed when working with large codebases. Every CLAUDE.md entry, every file read, and every conversation history segment consumes context space. When the context approaches its limit, the model may lose earlier information (the "lost in the middle" phenomenon), leading to degraded output quality. This is the technical reason Boris suggests keeping CLAUDE.md "as concise as possible" — verbose configuration files not only waste precious context space but may also dilute truly important instructions, reducing the model's adherence to key specifications.

Slash Commands and Custom Workflows

You can configure custom slash commands in .claude/commands files. For example, the Anthropic team has configured a GitHub Action to automatically label issues — Claude Code only needs to execute a single slash command to complete it without human intervention.

Memory Management Tips

Running the /memory command shows all loaded memory files, including enterprise policies, personal memories, project CLAUDE.md files, etc. Type # followed by content during a conversation to have Claude remember specific information at any time, with the option to choose which memory file to store it in.

Team Collaboration: MCP Servers and Tool Sharing

Claude Code supports two types of external tool extensions:

1. Bash tools: Directly invoke CLI tools — you can first have Claude use --help to learn usage
2. MCP tools: Connected via MCP JSON configuration files; once checked into the codebase, team members automatically get prompted to install

MCP (Model Context Protocol) is an open standard protocol released by Anthropic in late 2024, designed to establish a unified communication interface between AI models and external data sources/tools. Before MCP, every AI application needed custom integration code to connect with different tools (databases, APIs, browser automation, etc.), resulting in massive duplication of effort. MCP adopts a client-server architecture: the AI application acts as an MCP client making requests, while various tools expose their capabilities as MCP servers. The protocol defines standardized JSON-RPC message formats supporting tool discovery, parameter passing, and result return. This means once a Puppeteer MCP server is configured, any MCP-compatible AI client can directly invoke browser automation capabilities without developing duplicate adapter layers.

As an example from within Anthropic, they've checked in Puppeteer MCP server configurations in their application codebases. Every engineer can directly invoke it for end-to-end testing, automated screenshots, and rapid iteration without each person having to install and configure it separately.

Advanced Techniques: SDK and Parallel Workflows

How to Use the Claude Code SDK

Adding the -p parameter to the Claude command enables SDK mode, which supports passing prompts directly, specifying tool whitelists, and setting output formats (such as JSON or streaming JSON).

It works like a super-intelligent Unix tool, supporting piped input and output. For example, piping the output of git status to Claude Code, then extracting results with jq. This design continues the core Unix philosophy of "each program does one thing well, combined through pipes," allowing Claude Code to seamlessly integrate into existing Shell scripts and automation pipelines. Practical use cases include: pulling logs from GCP storage buckets for automated analysis, fetching data from Sentry for processing, and integrating into CI/CD pipelines for automated code quality reviews.

Parallel Sessions for Improved Efficiency

Power users both inside and outside Anthropic almost universally use SSH sessions with Tmux tunnels to run multiple Claude Code instances simultaneously. They typically clone multiple copies of the same repository or leverage Git Worktree for operational isolation, enabling massive parallel work.

Git Worktree is a feature introduced in Git 2.5 that allows creating multiple independent working directories under the same Git repository, each capable of checking out different branches. Compared to the traditional approach of "cloning multiple repository copies," Worktrees share the same .git object database without incurring extra disk overhead or sync issues. In AI programming scenarios, this feature is particularly important: developers can assign an independent Worktree to each Claude Code instance, with each instance modifying code on different branches in parallel without interference, avoiding file lock conflicts and merge chaos. Combined with Tmux's multi-pane management, developers can simultaneously monitor multiple AI agents' progress, achieving a truly parallelized development pipeline.

Quick Reference: Useful Shortcuts

• Shift+Tab: Enter auto-accept edits mode (Bash commands still require confirmation)
• # + content: Have Claude remember specific information
• ! + command: Run a Bash command locally and include the output in context
• Escape: Stop Claude's current operation at any time without corrupting the session
• Double Escape: Browse back through history
• Ctrl+2: View the complete information Claude sees in its context window
• --continue parameter: Resume a previous session

Why Command Line Instead of an IDE?

During the Q&A session, Boris explained two reasons for choosing the terminal form factor: first, Anthropic internally uses a wide variety of IDEs, and the terminal is the "lowest common denominator"; second, the team has witnessed firsthand the rapid evolution of model capabilities — Boris even predicts that "by the end of this year, people might not be using IDEs anymore" — so they don't want to over-invest in the UI layer.

Additionally, Boris revealed that approximately 80% of Anthropic's technical staff use Claude Code daily, including researchers who use it to edit and run notebooks. This high-intensity internal battle-testing is the core driving force behind the product's continuous evolution. This "dogfooding" strategy has a long tradition in the tech industry — when a product's core users are the development team itself, pain points are discovered and fixed most quickly, and the feedback loop for feature iteration is at its tightest.