Claude Code power user tips

This article collects workflow tips from the Claude Code team at Anthropic. These practices cover parallel execution, planning, automation, verification, and customization—the patterns the team uses every day to ship code faster. Everyone’s setup is different, so experiment to see what works for you.

The biggest productivity unlock is running 3–5 Claude sessions in parallel, each in its own git worktree. Claude Code has native worktree support built in.

To stay oriented across many sessions, name your worktrees, set up shell aliases (za, zb, zc) to jump between them, color-code your terminal tabs, and enable terminal notifications so you know when any Claude needs your attention. Many engineers keep a dedicated “analysis” worktree just for reading logs and running queries.

Subagents can also run in isolated worktrees, which is especially powerful for large batched changes. Add isolation: worktree to your agent’s frontmatter:

Then prompt naturally: “Migrate all sync IO to async. Batch the changes and launch 10 parallel agents with worktree isolation. Each agent should test its changes end to end, then put up a PR.”

The /batch command interviews you about a migration, then fans the work out to as many worktree agents as needed — dozens, hundreds, or more. Each agent works in isolation, tests its own changes, and creates a PR independently.

Press Shift+Tab to cycle into plan mode. Pour your effort into the plan so Claude can one-shot the implementation. The typical flow is: enter plan mode → refine the plan → switch to auto-accept edits → Claude executes.

A few patterns from the team:

Claude Code team’s reasoning: “It’s the best coding model I’ve ever used, and even though it’s bigger & slower than Sonnet, since you have to steer it less and it’s better at tool use, it is almost always faster than using a smaller model in the end.”

The math: less steering + better tool use = faster overall results, even with a larger model.

Run /effort to choose your effort level. The four levels are low (fewer tokens, faster), medium (default), high (more tokens, more intelligence), and max. The Claude Code team uses high for everything; switch to /effort max for hard debugging or architecture decisions where you want Claude to reason for as long as it needs. Max burns through usage limits faster, so activate it per session.

Don’t accept the first solution—push Claude to do better. A few prompts that work well:

Write detailed specs to reduce ambiguity before handing work off. The more specific you are, the better the output.

While Claude is actively working, use /btw to ask a quick question without interrupting it. It’s single-turn with no tool calls, but has full context of the conversation.

Claude Code isn’t just for writing code—it’s a powerful learning tool when you configure it to explain and teach.

Share a single CLAUDE.md file at your repo root, checked into git, with the whole team contributing. The key practice: anytime Claude does something incorrectly, add it to CLAUDE.md so it knows not to repeat the mistake.

After every correction, end with: “Update your CLAUDE.md so you don’t make that mistake again.” Claude is very good at writing rules for itself.

Install the GitHub Action with /install-github-action, then tag @claude in PR comments to add learnings to CLAUDE.md as part of the review:

This is “Compounding Engineering”—each correction makes every future session better.

Run /memory to configure Claude Code’s built-in memory system.

The naming maps to how REM sleep consolidates short-term memory into long-term storage.

One engineer on the team tells Claude to maintain a notes directory for every task and project, updated after every PR — then points CLAUDE.md at it.

Giving Claude a way to verify its work will markedly improve the quality of the final result. If Claude can close the feedback loop on its own, it will iterate until the output is right.

Verification looks different per domain—bash commands, test suites, simulators, browser testing—but the principle is the same. Invest in domain-specific verification.

For frontend work, install the Claude Code Chrome extension. Think of it like any other engineer: if you ask someone to build a website but don’t let them use a browser, will it look good? Probably not. With a browser, they’ll iterate until it does.

The team uses the Chrome extension every time they work on web code. Download it for Chrome or Edge at code.claude.com/docs/en/chrome.

The Claude Desktop app bundles the ability to automatically start and test web servers in a built-in browser. You can set up something similar in CLI or VS Code using the Chrome extension, or just use the Desktop app directly.

Append /simplify to any prompt after making changes. It runs parallel agents that review changed code for reuse, quality, efficiency, and CLAUDE.md compliance—all in one pass.

If you do something more than once a day, turn it into a skill or command. Skills are checked into .claude/commands/ and shared with the team. A few ideas:

Slash commands can include inline Bash to pre-compute info (like git status) without extra model calls.

Think of subagents as automations for your most common PR workflows. Drop .md files into .claude/agents/:

Each agent can have a custom name, color, tool set, allowed/disallowed tools, permission mode, and model. Set the default agent for your main conversation by adding "agent" to settings.json or using claude --agent <name>. Run /agents to get started.

Custom agents are a powerful primitive that often gets overlooked. Define a new agent in .claude/agents, then run claude --agent=<name>. Example of a read-only agent:

When a PR opens, Claude can dispatch a team of agents that each focus on a different concern — logic errors, security issues, performance regressions — and post inline comments. The Anthropic team built this for themselves first; code output per engineer increased significantly and reviews were the bottleneck.

Hooks let you deterministically run logic at points in the agent lifecycle. Ask Claude to add a hook to get started.

Example PostToolUse hook for auto-formatting:

Run /permissions to pre-allow common safe commands and check them into your team’s .claude/settings.json. This is the recommended alternative to skipping permissions entirely — you get fewer prompts while keeping an auditable allowlist. Full wildcard syntax is supported—try "Bash(bun run *)" or "Edit(/docs/**)".

Claude Code’s permission system layers prompt-injection detection, static analysis, sandboxing, and human oversight. A small set of safe commands is pre-approved out of the box; everything you add via /permissions is additive to that baseline.

Auto mode lets Claude make permission decisions on your behalf. Classifiers evaluate each action before it runs—safe operations get auto-approved, risky ones still get flagged. Enable it with claude --enable-auto-mode, or cycle to it with Shift+Tab during a session (plan mode → auto mode → normal mode).

Run /sandbox to opt into Claude Code’s open-source sandbox runtime. It runs on your machine and supports both file and network isolation, improving safety while reducing permission prompts. Three modes are available:

For very long-running tasks, ensure Claude can work uninterrupted. Recommended approaches:

For sandboxed environments, use --permission-mode=dontAsk or --dangerously-skip-permissions to avoid blocks.

/loop schedules a recurring task locally for up to 3 days at a time. A few examples the Claude Code team runs:

Unlike /loop, scheduled jobs run in the cloud — they keep working even when your laptop is closed.

Claude Code has a mobile app—download the Claude app for iOS/Android and tap the Code tab. An iMessage plugin is also available (/plugin install imessage@claude-plugins-official) to send tasks from any Apple device.

Move sessions back and forth between mobile, web, desktop, and terminal:

You can also enable “Enable Remote Control for all sessions” in /config.

Dispatch is a secure remote control for the Claude Desktop app. It can use your MCPs, browser, and computer with your permission—useful for catching up on Slack and emails, managing files, and doing things on your laptop when you’re away from it.

Connect Claude to your existing tools so it can search Slack, run BigQuery, grab Sentry logs, and more.

Ask Claude to use the bq CLI to pull and analyze metrics on the fly—keep a BigQuery skill checked into your codebase. The Claude Code team's take: “Personally, I haven’t written a line of SQL in 6+ months.” This works for any database that has a CLI, MCP, or API.

Enable the Slack MCP, paste a bug thread into Claude, and just say “fix”—zero context switching. Or say “go fix the failing CI tests” without micromanaging how. Point Claude at docker logs to troubleshoot distributed systems—it’s surprisingly capable at this.

Plugins bundle LSPs (available for every major language), MCPs, skills, agents, and custom hooks. Install from the official Anthropic plugin marketplace, or stand up an internal marketplace for your organization—then check the marketplace reference into settings.json so it’s auto-added for every developer. Run /plugin to get started.

Run /config to set light/dark mode and /terminal-setup to enable Shift+Enter for newlines in IDE terminals, Apple Terminal, Warp, or Alacritty. Run /vim for Vim mode. The team recommends Ghostty for synchronized rendering and 24-bit color.

Voice mode is available to all users, including Claude Code Desktop and Cowork. Most of the Claude Code team's coding is done by speaking—you speak roughly 3× faster than you type, and your prompts get more detailed as a result.

Beyond the terminal, run additional sessions on claude.ai/code. Use the & command to background a session, or the --teleport flag to switch contexts between local and web.

Run /config and set an output style. Explanatory has Claude explain frameworks and patterns as it works (great for new codebases). Learning has Claude coach you through changes. You can also create custom styles to adjust Claude’s voice.

It’s the little things that make Claude Code feel personal. Ask Claude to customize your spinner verbs to add to or replace the default list. Check the settings.json into source control to share verbs with your team.

Claude Code is built to work great out of the box, but when you do customize, check settings.json into git so your team benefits too. Configuration is supported per-codebase, per-subfolder, per-user, or via enterprise-wide policies.

By the numbers: dozens of settings and environment variables—see the settings reference. Use the "env" field in settings.json to avoid wrapper scripts.

By default, claude -p (and the TypeScript/Python SDKs) searches for local CLAUDE.md files, settings, and MCPs. For non-interactive usage, you usually want to specify these explicitly via --system-prompt, --mcp-config, --settings, etc. Add --bare for roughly 10× faster startup:

When working across repositories, use --add-dir (or /add-dir) to give Claude access and permissions to additional folders. Or add "additionalDirectories" to your team’s settings.json to always include them.

To branch off an existing session, run /branch from inside it, or claude --resume <session-id> --fork-session from the CLI.

In Claude Code on web and desktop, add a setup script that runs before each new cloud session—install dependencies, configure settings, set environment variables. The script is skipped on resume.

Claude Code ships frequently. Verify version-specific details against code.claude.com/docs before distributing internally.