50 Tips to Master Claude Code

Always launch Claude Code from the root directory of your project repository.

Claude Code zips and reads your project context from wherever you start it. Running from a subdirectory means Claude only sees part of your codebase, leading to incomplete understanding, missed dependencies, and incorrect suggestions. Starting from root ensures Claude has the full picture of your project structure, imports, and configurations.

Open your terminal, navigate to your project root (where your package.json, .git folder, or main config files live), and then run the claude command. If you are already in a subdirectory, cd back to root first.

Use the /init command as your very first action in a new project to generate a CLAUDE.md file.

The CLAUDE.md file is Claude Code's instruction manual for your project. Without it, Claude has no persistent knowledge of your project conventions, architecture, or rules. Running /init lets Claude analyze your entire codebase and generate a tailored CLAUDE.md automatically, saving you hours of manual documentation.

After starting Claude Code in your project root, type /init and press Enter. Claude will scan your codebase and generate a CLAUDE.md file with project structure, tech stack info, and initial rules.

Understand that CLAUDE.md operates on a hierarchical system, reading and prioritizing rules from top to bottom.

Rules at the top of your CLAUDE.md carry more weight and are processed first. This means your most critical instructions (like never delete the database or always use TypeScript) should be placed at the top. Misunderstanding this hierarchy can lead to conflicting rules where less important guidelines override critical ones.

Structure your CLAUDE.md with the most important rules and project identity at the top, followed by domain-specific guidelines, then workflow preferences, and finally nice-to-have suggestions at the bottom.

Aim for approximately 300 lines in your CLAUDE.md file to prevent context bloat.

Every line in CLAUDE.md consumes tokens from Claude's context window. An overly verbose CLAUDE.md (500+ lines) wastes valuable context space that could be used for actual coding tasks. This leads to reduced reasoning quality, higher costs, and slower responses.

Audit your CLAUDE.md regularly. Remove redundant rules, merge similar guidelines, and use concise language. If a rule can be stated in one line, do not use three. Remove rules that Claude already follows by default.

Organize your CLAUDE.md into three core sections: What (project requirements), Domain (business/technical context), and Validation (how to verify work).

This three-part structure gives Claude a complete mental model of your project. What tells Claude what the project does. Domain provides business logic and terminology. Validation gives Claude the tools to self-check its work through tests, linting, or build commands.

Create three clearly labeled sections in your CLAUDE.md. Under What, describe the project purpose and stack. Under Domain, explain key business concepts. Under Validation, list commands like npm test, npm run build, or specific test scripts.

Use the Shift+Tab keyboard shortcut to switch between Accept Edits mode and Plan Mode.

Plan Mode is essential for complex or new features because it forces Claude to think through the approach before writing code. This gives you a chance to course-correct before any code is written, preventing wasted time on wrong approaches.

Press Shift+Tab at any time to toggle between modes. Start new features in Plan Mode to get Claude's execution plan, review it, iterate if needed, then switch to Accept Edits mode to execute.

Press the Escape key to immediately stop Claude's current thinking or generation process.

Sometimes you can tell early on that Claude is heading in the wrong direction. Interrupting early lets you provide corrections and redirect Claude before it goes further down the wrong path.

Simply press the Escape key once while Claude is generating. This stops the current process and returns control to you. You can then provide new instructions or clarifications.

Quickly clear your current input field by double-tapping the Escape key.

When you have typed a long prompt but decide to start over, manually selecting and deleting text is slow. Double-tapping Escape instantly clears the input field.

With text in your input field, quickly press Escape twice in succession. The input field will be cleared instantly.

When your input field is already empty, double-tapping Escape lets you rewind to a previous context point.

This is Claude Code's built-in undo system. If Claude made changes you do not like, rewinding restores your context to an earlier state. It is faster than manually undoing changes.

Make sure your input field is empty, then double-tap Escape again. You will be presented with rewind options to choose from.

Take a screenshot and drag it directly into the Claude Code interface to provide visual context.

Sometimes showing Claude what you see is faster and more accurate than describing it. Claude can analyze images and understand visual context.

Use your system screenshot tool (Cmd+Shift+4 on Mac) to capture the relevant area, then drag the image file directly into the Claude Code terminal window.

Always provide a brief description or explanation alongside any screenshot you share with Claude.

While Claude can analyze images, it cannot always infer your intent from the image alone. Adding context directs Claude's attention to exactly what matters.

After dragging a screenshot into Claude Code, type a brief description of what Claude should focus on. Be specific: instead of 'fix this', say 'the dropdown menu is overlapping the header'.

Use the /clear command to completely wipe the current conversation context and start fresh.

Over time, your context window fills up with previous prompts and responses. Clearing context when starting a new task ensures Claude works with a clean slate and maximum available context.

Type /clear and press Enter. This removes all previous conversation history from the current session.

Use the /context command to visualize your current context window usage and identify what is consuming the most tokens.

Context is your most precious resource. The /context command shows you exactly how many tokens CLAUDE.md, MCPs, conversation history, and other elements are using.

Type /context at any time to see a breakdown of your current token usage. Look for unexpectedly large items, especially MCPs which can consume thousands of tokens.

Allow Claude Code's automatic context compaction to summarize your session when it gets long, rather than fighting it.

When your context window fills up, Claude Code automatically summarizes older parts. This compaction is surprisingly effective at preserving important information while discarding noise.

Simply continue working normally. When your context reaches capacity, Claude Code will automatically compact it. After compaction, Claude retains key decisions while freeing up space.

Use the /model command to change which AI model Claude Code uses for its responses.

Different models excel at different tasks. Sonnet is fast and efficient for everyday coding. Opus provides deeper reasoning for complex architectural decisions and tricky bugs.

Type /model and select from the available options. Switch to Opus for complex work, and back to Sonnet for routine tasks to save costs.

Use the /resume command to recover a previous session if your Claude Code instance is accidentally killed or disconnected.

Losing a session mid-task can be extremely frustrating. The /resume command restores your previous context, saving 15–30 minutes of re-setup time per incident.

After restarting Claude Code, type /resume to see a list of recoverable sessions. Select the one you want to continue.

Use the /mcp command to view all currently installed Model Context Protocols and their status.

Each MCP consumes context tokens just by being connected. Without visibility, you might have forgotten MCPs running that silently eat your context.

Type /mcp to see a list of all installed MCPs, their current status (connected/disconnected), and their approximate token usage. Disconnect MCPs you are not actively using.

Use /help to access a comprehensive list of all available slash commands and their descriptions.

Claude Code has many commands beyond the commonly used ones, and new commands are added with updates. Even experienced users discover new commands through /help.

Type /help at any time to see the full list of available commands with brief descriptions.

Use Git as your primary safety net for version control, not just Claude Code's rewind feature.

Git commits create permanent, shareable checkpoints that survive session resets, crashes, and context clears. Relying solely on rewind is risky because it is session-dependent.

Commit your code frequently, especially before asking Claude to make major changes. Use descriptive commit messages. Consider using branches for experimental Claude-driven changes.

Include a dedicated Critical Rules section in your CLAUDE.md with explicit never-do and always-do instructions.

A Critical Rules section acts as hard guardrails. For example, 'NEVER delete migration files' or 'ALWAYS run tests before committing' prevent catastrophic mistakes.

Add a clearly labeled section near the top of your CLAUDE.md. List rules in clear, direct language. Use NEVER and ALWAYS to make the intent unambiguous.

After manually correcting Claude, ask it to update your CLAUDE.md rules so the same mistake does not happen again.

If you correct Claude but do not update the rules, it will likely repeat the same mistake in future sessions. This creates a feedback loop that permanently improves Claude's behavior.

After correcting Claude, say something like: 'Add a rule to CLAUDE.md that we always use async/await instead of .then() chains in this project.'

Define specific keywords or phrases in your CLAUDE.md that trigger predefined skills or workflows when used.

Workflow triggers let you create shortcuts for complex, multi-step processes. This standardizes workflows across your team and reduces the chance of missing steps.

In your CLAUDE.md, define triggers like: 'When I say build the app, run npm run lint, then npm test, then npm run build.'

Include your project-specific CLAUDE.md file in your Git repository so the entire team benefits from it.

When CLAUDE.md is committed to the repo, every team member who uses Claude Code automatically gets the same rules, conventions, and workflow triggers.

Simply git add CLAUDE.md and commit it like any other project file. Update it through pull requests so the team can review and discuss rule changes.

Use the --dangerously-skip-permissions flag when running Claude Code in non-critical, throwaway environments.

By default, Claude Code asks for permission before executing potentially dangerous commands. In safe environments like Docker containers or CI pipelines, these prompts slow you down.

Run Claude with: claude --dangerously-skip-permissions. Only use in isolated environments like Docker containers, VMs, or throwaway instances.

Pair the dangerously-skip flag with the /permissions command to selectively allow or block specific actions.

Using dangerously-skip alone is all-or-nothing. Combining it with allowlists gives you granular control: auto-approve common safe actions while requiring confirmation for dangerous ones.

Use /permissions to define which commands Claude can execute freely, and which still need approval. Then use dangerously-skip for the approved category.

Always begin new feature development by switching to Plan Mode before writing any code.

Jumping straight into code generation without a plan often leads to rework. Plan Mode forces Claude to think through the architecture, identify affected files, and consider edge cases before touching any code.

Press Shift+Tab to enter Plan Mode. Describe the feature you want to build. Review Claude's proposed plan, iterate until satisfied, then switch to execution mode.

Prioritize working with fresh, condensed context over accumulated, bloated context from long sessions.

As your session grows, the context window fills with outdated information and failed attempts. A fresh context with only relevant information produces better results, uses fewer tokens, and generates faster responses.

Use /clear when switching tasks. Start new sessions for new features rather than continuing marathon sessions.

Save your current context and progress before ending a Claude Code session.

When you close Claude Code, your conversation context is lost unless you explicitly save it. Persisting your state can save 10–15 minutes of re-setup time.

Before ending a session, ask Claude to summarize the current state and next steps. Save to a file or add relevant notes to CLAUDE.md.

Load context only when it is actually needed for the current task, rather than preloading everything upfront.

Loading all possible context at the start wastes tokens on information you may never use. Lazy loading keeps your context lean and relevant.

Start with minimal context. Use @-mentions to bring specific files into context only when the conversation reaches that topic. Avoid loading entire directories upfront.

Integrate build commands, debugging logs, and automated tests into your workflow so Claude can verify its own work.

Without verification commands, Claude cannot tell if its changes actually work. Providing commands like npm test creates an autonomous improvement loop.

Add verification commands to your CLAUDE.md Validation section. Include: build command, test command, linting command, and any project-specific validation scripts.

Switch to the Opus model for challenging tasks that require deep reasoning and complex problem-solving.

Opus excels at debugging subtle race conditions, designing complex systems, refactoring tightly coupled code, and making architectural decisions. The cost is higher, but quality justifies it.

Use /model to switch to Opus before tackling a complex task. Switch back to Sonnet for straightforward implementation once the approach is decided.

Pay close attention to Claude's extended thinking blocks to identify assumptions, errors, and reasoning patterns.

Thinking blocks reveal Claude's internal reasoning process. Catching errors here is far cheaper than catching them in generated code.

When Claude generates a response, read through the thinking section. Verify Claude's understanding, assumptions, and planned approach. If you spot an error, interrupt (Escape) and correct it.

Understand the four core composable building blocks of Claude Code: Skills, Commands, MCPs, and Subagents.

These four primitives are the foundation of Claude Code's extensibility. Mastering them transforms Claude from a simple code assistant into a customizable development platform.

Learn each primitive individually, then experiment with combining them. Start with the primitive that addresses your biggest current pain point.

Create Skills to encapsulate and automate workflows that you perform repeatedly.

Skills capture patterns as reusable templates that Claude can execute consistently. This eliminates repetitive instruction-giving and ensures consistency.

Identify workflows you perform more than twice. Ask Claude to create a Skill for each one. Skills are stored in your project and can be triggered by name.

Use Commands as quick shorthands for actions you perform frequently.

Commands are lighter-weight than Skills and serve as quick triggers for common actions. They reduce typing and ensure consistent execution.

Define Commands for your most frequent single-step actions: run test suite, format code, or generate a specific type of file.

Always ask Claude to create or update Skills and Commands for you rather than writing them by hand.

Claude understands the correct format, syntax, and best practices. Manually creating them risks syntax errors or suboptimal structure.

Simply tell Claude what you want. For example: 'Create a skill called deploy-staging that runs our staging deployment pipeline with all safety checks.'

Think of MCPs (Model Context Protocols) as connectors that let Claude interact with external services and tools.

MCPs dramatically extend what Claude can do by connecting it to databases, design tools, project management, and cloud services. They are particularly powerful for cross-tool workflows.

Use /mcp to see available MCPs. To find new ones, ask Claude: 'Find me an MCP for [service name].'

Have Claude manage the installation and configuration of MCPs instead of doing it manually.

MCP installation involves configuration files, authentication setup, and sometimes dependency management. Claude knows the correct steps for popular MCPs.

Tell Claude which MCP you want: 'Install the Figma MCP' or 'Set up the PostgreSQL MCP for our database.'

Use Subagents to perform parallel or atomic tasks with isolated context windows, protecting your main context.

Subagents run as separate instances with their own context. They return only results, keeping your main context clean. Invaluable for running tests while coding or exploring multiple approaches simultaneously.

Explicitly request them: 'Use a subagent to research the best pagination library' or 'Spawn a subagent to run the test suite while we continue working.'

Keep your prompts concise and avoid giving Claude too many instructions at once.

When you overload Claude with instructions, attention is divided and quality suffers. Breaking work into focused, sequential prompts produces better results.

Instead of one massive prompt, break work into logical steps. Complete and verify each step before moving to the next.

Operate multiple Claude Code instances simultaneously to juggle different tasks and maximize productivity.

Running multiple instances lets you assign each to a different task, effectively multiplying your throughput. Each instance maintains its own context.

Open multiple terminal windows. Start a separate Claude Code instance in each. Assign each to a specific task or area of your codebase.

Use split panes in iTerm (or similar terminal emulators) to manage multiple Claude Code instances on a single screen.

Split panes let you see all instances simultaneously, monitor their progress, and quickly switch between them.

In iTerm, use Cmd+D for vertical split and Cmd+Shift+D for horizontal split. Start a Claude Code instance in each pane.

Configure Claude Code to send notifications (sounds or system alerts) when tasks complete.

When Claude is working on a long-running task, notifications let you fully focus on other work and respond immediately when Claude needs input or has finished.

Enable notifications in your Claude Code settings or terminal configuration. Configure sound alerts for task completion, error encounters, or input needs.

Use Git worktrees to work on different code executions within the same project simultaneously without branch switching.

Git worktrees create separate working directories that share the same Git repository but operate on different branches. Zero risk of file conflicts.

Create a worktree with: git worktree add ../my-feature feature-branch. Run a separate Claude Code instance in each worktree.

Use the /chrome command to connect Claude Code to a browser, enabling it to navigate web pages and interact with web interfaces.

Claude can navigate to your running application, inspect UI elements, read console errors, interact with forms, and scrape documentation sites.

Type /chrome to establish a browser connection. Claude can then navigate URLs, interact with elements, take screenshots, and read page content.

Leverage the /chrome browser connection for advanced debugging of web applications.

With /chrome, Claude can directly navigate to the problematic page, fill forms, read console errors, inspect network requests, and observe actual behavior.

Connect /chrome, then ask Claude to navigate to the buggy page. Describe the bug and let Claude reproduce and investigate it firsthand.

Implement hooks (pre-hooks and post-hooks) to automatically perform actions before or after Claude executes commands.

Hooks add automation layers. Pre-hooks can validate inputs; post-hooks can clean up or verify results. This creates reliable, automated workflows.

Define hooks in your Claude Code configuration. Pre-hooks run before specified commands, post-hooks run after.

Set up PostToolUse hooks to automatically format or lint code after every edit Claude makes.

Claude generates well-structured code but may not always match your exact formatting preferences. PostToolUse hooks ensure all code matches your standards automatically.

Configure a PostToolUse hook that runs your project's formatter after Claude edits files. For example, run prettier --write on modified files.

Use hooks to prevent Claude from executing commands that could cause catastrophic damage.

A pre-hook that blocks commands like rm -rf /, DROP DATABASE, or force pushes to main acts as a final safety net against catastrophic mistakes.

Create pre-hooks that intercept commands and check them against a blocklist. Include patterns for database destruction, recursive deletion, and force pushes to protected branches.

Discover and utilize community-shared plugins that combine various composable elements for enhanced workflows.

The community creates and shares plugins for common workflows like CI/CD integration, code review automation, and documentation generation. This accelerates your setup.

Search for Claude Code plugins in community repositories, forums, and the official ecosystem. Evaluate and install plugins that match your workflow.