Claude Code Mastery Guide

Claude Code features an improved permission system to keep you in control of what actions are performed.

✅ Be Clear and Specific

Good: "Add input validation to the email field in the registration form"

Less good: "Fix the form"

✅ Let Claude Explore First

Claude can read and understand your codebase. Let it explore before making changes.

✅ Review Changes

Claude shows you all changes. Review them before committing.

✅ Ask Questions

"Why did you make this change?" or "What does this function do?" - Claude loves explaining!

✅ Iterate and Refine

If something isn't quite right, just say so. "Can you make this more efficient?" or "Add comments to explain this logic"

🚀 What is Claude Code Web?

Claude Code Web is a cloud-based coding agent that runs on Anthropic's infrastructure. It connects directly to your GitHub repositories and can handle multiple coding tasks in parallel.

Available at: claude.com/code

Requirements: Pro or Max subscription plan

🔄 Parallel Task Execution

Run multiple tasks across different repositories simultaneously from a single browser interface. Perfect for working through bug backlogs or testing multiple approaches.

🔗 GitHub Integration

Connect your GitHub repos directly. Claude Code Web can explore your codebase, make changes, and automatically create pull requests with detailed summaries.

📊 Real-Time Monitoring

Each task runs in its own isolated environment with live progress tracking. You can monitor Claude's work and redirect it as needed.

🔒 Sandbox Security

Every task runs in an isolated sandbox with network and filesystem restrictions. Git interactions go through a secure proxy, and you control which domains Claude can access (like npm registries).

⚡ Teleport Between Web and CLI

Start a task in the browser and seamlessly continue it in your terminal, or vice versa. This gives you flexibility to work wherever makes sense.

🔄 Test-Driven Development

🐛 Debugging Workflow

📦 Dependency Management

🏗️ Code Architecture

When you need Claude to think deeply about complex problems, you can request extended reasoning. Claude will break down the problem step-by-step before providing a solution.

When to use:

• Complex architectural decisions
• Debugging difficult issues
• Algorithm design
• Comprehensive code reviews
• Performance optimization analysis

Claude Code now features a dedicated Plan subagent that creates detailed, structured implementation plans before executing. This specialized agent helps with:

• Multi-file refactoring
• Large feature implementations
• System-wide changes
• Migration projects
• Complex architectural decisions

How it works: The Plan subagent automatically activates when Claude detects complex tasks that benefit from upfront planning. You can also explicitly request planning.

The Typical Scenario

You have 1-2 engineers who are experts on a critical system:

• Sarah is the only one who understands the legacy payment processing system
• Mike is the deployment guru—only he knows how to safely ship changes
• The database schema makes sense only to Chen

The Impact:

• 🚫 PRs sit waiting for expert review (days/weeks)
• ⏰ Simple tasks become major blockers
• 😰 Experts become burned out gatekeepers
• 🆘 New team members can't contribute effectively
• 💸 Organization velocity grinds to a halt

Claude Code can capture expert knowledge and make it available to your entire team through:

• Sub-agents that embody expert decision-making
• Skills that encode specialized workflows
• Custom slash commands for common expert tasks
• Project documentation that Claude references automatically

Result: Any engineer can get expert-level guidance instantly, without waiting for the expert to be available.

🏦 FinTech Startup: 10-Person Team, 1 Backend Expert

Before: Michael was the only engineer who understood their legacy Erlang backend. Every backend change waited for his review (5-7 days). He was burned out and considering leaving.

Solution:

• Created "erlang-expert" sub-agent with Michael's knowledge
• Built Skills for common backend tasks (deployment, debugging, profiling)
• Documented the Erlang codebase architecture with Michael's commentary

Results after 6 weeks:

• ✅ Review time dropped from 5-7 days to <1 day
• ✅ 4 other engineers now comfortable making backend changes
• ✅ Michael focuses on architecture, not routine reviews
• ✅ PR throughput increased 3x

🏥 Healthcare SaaS: HIPAA Compliance Bottleneck

Before: Only 2 engineers (Lisa and Tom) understood HIPAA compliance. Security reviews took 2-3 weeks. The company struggled to ship features.

Solution:

• Created "hipaa-compliance-reviewer" sub-agent encoding Lisa and Tom's expertise
• Built "/hipaa-check" slash command for instant compliance review
• Created Skills for common compliance patterns (PHI handling, audit logging)

Results after 3 months:

• ✅ Compliance review time: 2-3 weeks → 1-2 days
• ✅ 100% of engineers can now make HIPAA-compliant changes
• ✅ Zero compliance violations since implementing
• ✅ Lisa and Tom now consult on complex cases only (20% of previous workload)

🚀 SaaS Company: Database Performance Expert Bottleneck

Before: Priya was the only engineer who could optimize database queries. Slow queries plagued production. Priya was involved in every database-related decision.

Solution:

• Created "db-performance-expert" sub-agent with Priya's optimization knowledge
• Built Skills for query analysis, index recommendations, and migration review
• Created "/explain-query" command that breaks down query performance like Priya would

Results after 2 months:

• ✅ 8 engineers now capable of query optimization (up from 1)
• ✅ Average query optimization time: 3 days → 4 hours
• ✅ Database query issues dropped 70%
• ✅ Priya now focuses on database architecture strategy

Key Metrics to Track

Measure the impact of democratizing expertise:

Before vs After Metrics:

• PR Review Time: How long PRs wait for expert review
• Expert Utilization: % of expert's time on routine vs complex problems
• Team Capability: # of engineers who can work on the system
• Incident Response Time: How fast team can debug issues
• Onboarding Time: How long until new hires are productive
• Expert Satisfaction: Is the expert less burned out?

Leading Indicators (What to Watch):

• Sub-agent activation frequency (shows it's being used)
• Skill usage counts
• Slash command execution frequency
• Questions in Slack to the expert (should decrease)
• PR self-sufficiency (fewer "can you look at this?" messages)

Week 1 Action Plan

1. Day 1-2: Identify your top knowledge bottleneck (poll the team or check PR review times)
2. Day 3: Schedule 1-hour knowledge extraction session with the expert
3. Day 4-5: Create the first sub-agent or skill based on the interview
4. Week 2-3: Have team try it on real work, collect feedback
5. Week 4: Refine based on feedback, measure impact, present results

Time Investment: 4-6 hours of expert time, 1-2 days of implementation. Payback: Within 2-4 weeks as the team becomes self-sufficient.

Sub-agents are like having a team of specialized experts working alongside you. Each sub-agent has:

• Specialized expertise: Fine-tuned for specific domains (code review, debugging, testing, etc.)
• Isolated context: Separate context windows that don't clutter your main conversation
• Custom tool access: Only the tools they need, improving security and focus
• Reusability: Can be shared across projects and teams
• Dynamic model selection: Claude intelligently chooses the optimal model (Sonnet/Opus/Haiku) for each sub-agent based on task complexity
• Resumability: Sub-agents can be paused and resumed dynamically without losing context

📁 Project Sub-agents

Location: .claude/agents/ in your project

When to use: Project-specific workflows, team conventions, repo-specific tools

Best for: Teams sharing common patterns

👤 User Sub-agents

Location: ~/.claude/agents/ in your home directory

When to use: Personal workflows, cross-project patterns, your preferred conventions

Best for: Individual productivity patterns

🔌 Plugin Sub-agents

Source: Installed plugins

When to use: Pre-built expertise from the community

Best for: Standard patterns (React, Python, security, etc.)

1️⃣ Use the Explore Agent for Codebase Discovery

When working with unfamiliar or large codebases, delegate exploration tasks to the Explore agent:

Why it works: The Explore agent has specialized tools and prompts for codebase navigation, keeping your main conversation focused on your task.

2️⃣ Create Domain-Specific Search Agents

For large codebases with distinct domains, create specialized search agents:

3️⃣ Use Sub-agents to Preserve Context

In long sessions with large codebases, your main context can get cluttered. Use sub-agents strategically:

4️⃣ Chain Sub-agents for Complex Workflows

Orchestrate multiple sub-agents for sophisticated analysis:

5️⃣ Write Detailed, Specific Descriptions

For automatic invocation, make descriptions action-oriented:

6️⃣ Limit Tool Access Strategically

Give sub-agents only the tools they need:

Benefits: Better security, faster execution, clearer purpose, fewer accidental changes

7️⃣ Version Control Your Sub-agents

Treat project sub-agents as code - commit them to your repository:

🔄 Automatic Invocation

Claude automatically delegates when your request matches a sub-agent's expertise:

🎯 Explicit Invocation

You can also specifically request a sub-agent:

Claude now intelligently selects the optimal model for each sub-agent based on task complexity, balancing performance, speed, and cost:

How it works: You don't need to specify the model. Claude automatically assesses the task and selects the most appropriate model for each sub-agent invocation. This ensures optimal performance while managing costs.

Sub-agents can now be paused and resumed without losing context. This is especially useful for:

• Long-running analysis: Resume after interruptions or when you need to provide additional context
• Iterative refinement: Continue refining an agent's analysis based on new information
• Multi-stage workflows: Break complex tasks into stages and resume between them

Skills package expertise into discoverable components that Claude can use on its own. Each Skill contains:

• SKILL.md file: Instructions and metadata in YAML frontmatter
• Supporting files: Scripts, templates, documentation, and utilities
• Tool restrictions: Optional limits on what Claude can do
• Automatic activation: Claude decides when to use them based on context

📄 PDF Processing Skill

Use case: Extract text, fill forms, merge PDFs, generate reports

Files included: SKILL.md, pdf-utils.py, form-templates/, examples.md

📊 Excel Data Analysis Skill

Use case: Analyze spreadsheets, create pivot tables, generate charts

Files included: SKILL.md, excel-utils.py, chart-templates/, sample-analysis.md

🔒 Security Auditor Skill

Use case: Scan code for vulnerabilities, check dependencies, validate configs

Files included: SKILL.md, security-patterns.md, checklist.md

🌐 API Documentation Generator

Use case: Auto-generate API docs from code, create OpenAPI specs

Files included: SKILL.md, templates/openapi.yaml, templates/markdown.md, examples/

🧪 Test Generator Skill

Use case: Generate unit tests, integration tests, and test fixtures

Files included: SKILL.md, test-templates/, fixture-examples/

📝 Technical Writer Skill

Use case: Create user guides, READMEs, tutorials, and architecture docs

Files included: SKILL.md, templates/, diagram-examples/, style-guide.md

🚀 CI/CD Pipeline Builder

Use case: Generate GitHub Actions, GitLab CI, or other pipeline configs

Files included: SKILL.md, templates/github-actions.yml, templates/gitlab-ci.yml, examples/

1. Keep Scope Focused

Create specific Skills rather than broad ones:

2. Write Descriptive Descriptions

Include both what it does AND when to activate:

3. Use Tool Restrictions Wisely

Limit tools to prevent unintended actions:

4. Include Supporting Resources

Organize your Skill directory effectively:

5. Test Your Skills Thoroughly

Ensure your Skill activates correctly:

• Test with various phrasings of requests
• Verify it doesn't activate for unrelated tasks
• Check that instructions are clear and unambiguous
• Validate tool restrictions work as expected
• Get feedback from team members

🔄 Automatic Activation

Just work naturally—Claude will use Skills when relevant:

🎯 Check Available Skills

See what Skills are available:

📦 Project Skills (Recommended)

Commit Skills to your repository for automatic team sharing:

🔌 Plugin Skills (For Broader Distribution)

Package Skills as plugins for the Claude Code community:

• Create a plugin with your Skill included
• Publish to the plugin marketplace
• Others can install with /plugin install
• Automatic updates when you release new versions

MCP is a protocol that lets Claude Code interact with external systems like databases, APIs, cloud services, and more. Think of it as giving Claude superpowers to access data and services beyond your local filesystem.

🎯 Real-World MCP Use Cases

• Data Analysis: "Compare sales data from our PostgreSQL database with the projections in Google Sheets"
• DevOps: "Check the status of all our AWS EC2 instances and alert me if any are overutilized"
• Project Management: "Show me all high-priority bugs from Jira and create a summary report"
• Documentation: "Pull all our API docs from Notion and generate a unified developer guide"

🎯 user-prompt-submit-hook

Runs after you submit a message. Perfect for:

• Running linters before Claude edits code
• Checking git status
• Validating environment setup

⚡ tool-call-hook

Runs before specific tool calls. Use to:

• Backup files before edits
• Run formatters after writes
• Validate changes

🛡️ What is Sandbox Mode?

Sandbox mode creates isolated environments where bash commands run with restricted access to your filesystem and network. This is especially important when working with unfamiliar code or delegating tasks.

Available on: Linux and macOS

Status: Enabled by default in Claude Code Web

📁 Filesystem Restrictions

Commands can only access specific directories and files, preventing accidental or malicious changes to system files.

🌐 Network Controls

You can specify which domains and URLs Claude can access, such as package registries (npm, pip) while blocking others.

🔐 Git Proxy

Git operations go through a secure proxy that restricts access to authorized repositories only.

Think of plugins as pre-packaged extensions that bundle together:

• Custom Commands: Slash commands for specific workflows
• Agents: Specialized AI agents for particular tasks
• Hooks: Automated event handlers
• MCP Servers: Connections to external tools and services

Plugins make it easy to share best practices and tooling across your entire team or organization.

Organization-Wide Plugin Distribution

🔗 Learn More About Plugins

For detailed technical documentation, see:

• Plugins Guide - Complete documentation

🔄 Automated Code Migration

🎯 Multi-Repository Operations

📊 Automated Reporting

🏗️ Project Scaffolding

Use the --max-budget-usd flag when running Claude Code via the SDK to set hard spending limits:

What happens when budget is reached: Claude will gracefully stop execution, save your session, and provide a summary of what was completed before the budget limit was hit.

Know which models Claude uses for different tasks to estimate costs:

By default, Claude Code excludes files and directories listed in .gitignore from:

• File searches (Glob, Grep)
• Codebase exploration
• Sub-agent analysis
• Context gathering

Why this matters: This keeps operations fast, focused on source code, and avoids overwhelming Claude with irrelevant files like node_modules, build artifacts, or vendor dependencies.

Sometimes you need to work with .gitignored files. Common scenarios:

• Build artifacts: Analyzing generated JavaScript from TypeScript
• Vendor dependencies: Debugging issues in node_modules
• Generated code: Reviewing auto-generated API clients
• Config files: Working with local development configs
• Logs: Analyzing error logs during debugging

1. Understanding a New Codebase

Scenario: You've joined a new team and need to understand a large, unfamiliar codebase.

Result: Comprehensive understanding in hours instead of weeks.

2. Building a Complete Feature

Scenario: Add a complex new feature from scratch.

Result: Complete, production-ready feature with tests and docs.

3. Debugging Complex Issues

Scenario: Intermittent bug that's hard to reproduce.

Result: Root cause identified and fixed with preventive measures.

4. Legacy Code Modernization

Scenario: Modernize old codebase to current standards.

Result: Systematic, safe migration to modern framework.

5. Performance Optimization

Scenario: Application is slow and needs optimization.

Result: Significantly faster application with measurable improvements.

6. API Development

Scenario: Build a complete REST API from scratch.

Result: Complete API with auth, tests, docs, and error handling.

7. Data Pipeline Creation

Scenario: Build automated data processing pipeline.

Result: Automated daily analytics reporting.

8. Data Cleaning & Transformation

Scenario: Clean messy data from multiple sources.

Result: Clean, normalized data ready for analysis.

9. Exploratory Data Analysis

Scenario: Understand a new dataset.

Result: Comprehensive analysis with actionable insights.

10. SQL Query Generation & Optimization

Scenario: Complex database queries needed.

Result: Optimized queries with performance insights.

11. Comprehensive Documentation

Scenario: Project has minimal documentation.

Result: Professional, comprehensive documentation suite.

12. Technical Report Generation

Scenario: Need to report on project status to stakeholders.

Result: Professional report ready for stakeholders.

13. Knowledge Base Creation

Scenario: Create internal documentation from tribal knowledge.

Result: Comprehensive onboarding documentation.

14. Test Suite Generation

Scenario: Code has insufficient test coverage.

Result: Complete test suite with high coverage.

15. Automated Testing Workflow

Scenario: Set up continuous testing.

Result: Automated testing pipeline ensuring quality.

16. Docker & Kubernetes Setup

Scenario: Containerize application.

Result: Production-ready containerized application.

17. Infrastructure as Code

Scenario: Define infrastructure programmatically.

Result: Complete IaC setup for reproducible infrastructure.

18. Configuration Management

19. Dependency Analysis

20. Code Archaeology

📄 Essential Reading for Teams

Scaling Agentic Coding Across Your Organization

Comprehensive guide from Anthropic covering:

• Change management strategies for AI adoption
• Security and governance considerations
• Measuring ROI and productivity gains
• Best practices from enterprise deployments

Perfect for engineering leaders, CTOs, and team leads

📚 More Examples Coming Soon

Additional workflows in development:

• Code Review Checklist - Automated reviews based on team standards
• Performance Dashboard - Track and visualize app metrics
• Documentation Generator - Auto-generate comprehensive docs

View all examples on GitHub →

Common Commands

File Locations

Useful Prompts

• "Explain how this codebase works"
• "Find and fix this bug: [description]"
• "Refactor [function/module] to be more efficient"
• "Add comprehensive tests for [feature]"
• "Generate documentation for this project"
• "Review my changes and suggest improvements"
• "Help me debug why [issue] is happening"

1. Scoping Strategy

Before starting large refactors:

• Create a dependency map before making changes
• Start with leaf nodes (fewest dependencies) first
• Focus on the change surface, not understanding everything

2. Search Efficiency Patterns

• Use Glob to narrow scope first, then grep within results
• Always specify file types or paths
• Read files only when targeted - don't explore randomly

3. Library Replacement Workflow

Phase 1: Discovery (use Explore agent)

• Find all import statements
• Identify usage patterns
• Document edge cases

Phase 2: Categorization (use TodoWrite heavily)

• Group by usage type (simple vs complex)
• Create separate todos for each file/pattern
• Mark dependencies between changes

Phase 3: Execution (parallel when possible)

• Replace simple usages first (builds confidence)
• Test after each logical group
• Use git commits to create checkpoints

4. Language Translation Best Practices

Work module-by-module, not file-by-file:

1. Translate API contracts/interfaces first
2. Translate data models next
3. Translate business logic
4. Translate tests last (they guide translation)

5. Managing Context Windows

Claude Code works best with focused tasks:

• Break work into ~1000-2000 line chunks
• Each module or service as separate task
• Clear interfaces between chunks
• Test each chunk before moving on

6. Parallel Operations

When changes are independent, request parallel work:

Claude will read multiple files simultaneously, make edits in parallel, and track progress across all modules.

7. Checkpoint Strategy

For weeks-long refactors, commit strategically:

This lets you pause/resume and isolate issues effectively.

8. Testing at Scale

Don't wait until the end!

After each module:

• Run unit tests for that module
• Run integration tests that touch it
• Check compilation/type errors

9. Common Pitfalls

10. Performance Tips

Speed up large operations:

1. Use specific paths: grep "pattern" src/module not grep "pattern" .
2. Exclude unnecessary directories: Add to .gitignore: node_modules, build, dist, .git
3. Use file type filters: --type=py instead of **/*.py
4. Request parallel operations: "Work on these 3 files in parallel"
5. Use count mode for scoping: grep "oldLib" --output_mode=count

📊 Real Example: Library Migration

Task: Replace Moment.js with date-fns across 8M line React app

Step 1: Scope (use Explore agent)

Step 2: Categorize findings

• 1,247 files use Moment
• 6 common patterns identified
• 43 edge cases flagged

Step 3: Create strategy

• Write custom slash command for common patterns
• Use TodoWrite to track all 1,247 files
• Group into 50-file batches

Step 4: Execute incrementally

• Start with components (fewest dependencies)
• Then utilities
• Then page-level code
• Tests last

Step 5: Verify continuously

• npm test after each batch
• Fix type errors immediately
• Commit after each successful batch

Result: 3-week migration, tracked with 25 git commits

11. Custom Tools for Repeated Operations

For repetitive large-scale tasks, create:

Slash commands:

Hooks:

• Pre-commit hook to check for banned imports
• Pre-write hook to enforce new patterns

MCPs:

• Custom MCP to query internal architecture docs
• Custom MCP to validate against your style guide

Anthropic Blog Posts

• Announcing Claude Code
• Understanding MCP
• Best Practices for AI-Assisted Development

External Resources

• Prompt Engineering Guide: Learn effective prompting techniques
• AI-Assisted Development: Patterns and practices
• Code Quality with AI: Maintaining standards

❌ Claude won't start / "Command not found"

Problem: When I type claude, I get "command not found"

Solutions:

1. Verify installation: which claude
2. Reinstall: npm install -g @anthropic-ai/claude-code
3. Check your PATH environment variable
4. Try with npx: npx @anthropic-ai/claude-code
5. Restart your terminal after installation

🔑 API Key / Authentication Issues

Problem: "Authentication failed" or "Invalid API key"

Solutions:

1. Verify key is set: echo $ANTHROPIC_API_KEY
2. Set key: export ANTHROPIC_API_KEY=your-key
3. Add to your shell profile (~/.zshrc or ~/.bashrc) to make it permanent
4. Check key is valid in Anthropic Console
5. Regenerate key if needed

🔒 Permission Errors

Problem: "Permission denied" when reading/writing files

Solutions:

1. Check file permissions: ls -la filename
2. Make sure you're running Claude Code from the correct directory
3. Check that .gitignore isn't blocking the files
4. Verify you have write access to the project directory
5. Don't use sudo unless absolutely necessary (not recommended)

🤐 Claude Isn't Responding

Problem: Claude started but isn't responding to my messages

Solutions:

1. Check your internet connection
2. Verify you haven't hit API rate limits
3. Try /clear to reset the conversation
4. Restart Claude Code completely
5. Check Anthropic status page
6. Look for error messages in your terminal

🐛 Claude Made a Mistake

Problem: The code Claude wrote has bugs or isn't what I wanted

Solutions:

1. Be more specific in your request and provide more context
2. Ask Claude to fix it: "This has a bug in line 42 where..."
3. Iterate: "Can you try a different approach?"
4. Provide examples of what you want
5. Undo with git: git restore <file>
6. Ask Claude to explain its reasoning: "Why did you choose this approach?"

↩️ How Do I Undo Changes?

Problem: I want to revert Claude's changes

Solutions:

1. Single file: git restore <file>
2. All changes: git restore .
3. Hard reset: git reset --hard HEAD (careful!)
4. Pro tip: Always review changes before accepting
5. Pro tip: Work in a branch: git checkout -b feature-name
6. Pro tip: Commit frequently so you can easily revert

🐌 Performance Is Slow

Problem: Claude is taking a long time to respond

Solutions:

1. Large codebases (>100k lines) may be slower—this is normal
2. Be specific to reduce scope: "Fix the login function" vs "Fix everything"
3. Check your internet connection speed
4. Try smaller, focused questions
5. Use agents for long-running tasks that can work in the background
6. Break complex tasks into smaller steps

📁 Claude Can't Find My Files

Problem: Claude says it can't find a file that exists

Solutions:

1. Check the file path is correct: ls path/to/file
2. Make sure you're in the right directory: pwd
3. Check if the file is in .gitignore (Claude respects .gitignore)
4. Try using the full path instead of a relative path
5. Ask Claude to search: "Find all files named X"

🔌 MCPs Not Working

Problem: My MCP server isn't connecting

Solutions:

1. Check ~/.mcp.json formatting (must be valid JSON)
2. Verify the MCP server is installed: npm list -g
3. Check logs for error messages
4. Try a simple test MCP first (like filesystem)
5. Restart Claude Code after changing MCP config
6. Verify the server path is correct

🪝 Hooks Not Firing

Problem: My hooks aren't running

Solutions:

1. Check .claude/config.json syntax (must be valid JSON)
2. Verify hook commands work independently in terminal
3. Check file permissions on hook scripts: chmod +x script.sh
4. Look for error messages in Claude Code output
5. Try a simpler hook first to test the system
6. Make sure the hook path is absolute or relative to project root

⌘ Custom Commands Not Working

Problem: My custom slash command doesn't show up

Solutions:

1. Check command file location: .claude/commands/commandname.md
2. Verify file name matches: /commandname → commandname.md
3. Restart Claude Code after adding new commands
4. Check file has content (can't be empty)
5. Try /help to see if your command is listed

🔌 Plugins Not Working

Problem: My installed plugin isn't working or showing up

Solutions:

1. Verify plugin is installed: /plugin list
2. Check plugin is enabled: /plugin enable plugin-name
3. Restart Claude Code after installing plugins
4. Verify plugin marketplace URL is correct: /plugin marketplace
5. Check plugin manifest (.claude-plugin/plugin.json) is valid JSON
6. Try reinstalling: /plugin uninstall plugin-name then reinstall
7. Check plugin documentation for specific requirements

💰 How much does Claude Code cost?

Claude Code uses your Anthropic API key, which is billed based on usage. You can check pricing at anthropic.com/pricing. You only pay for what you use.

🔐 Is my code secure?

Your code is sent to Anthropic's API for processing. Anthropic does not train models on your API data. Review Anthropic's privacy policy for full details.

🌐 Can I use Claude Code offline?

No, Claude Code requires an internet connection to communicate with Anthropic's API. All the AI processing happens in the cloud.

👥 Can multiple people use Claude Code on the same project?

Yes! Each person needs their own API key. Claude Code works great in team environments. Just make sure to use git branches to avoid conflicts.

📦 What languages/frameworks does Claude Code support?

Claude Code works with all programming languages and frameworks. It's especially good with popular languages like Python, JavaScript/TypeScript, Java, Go, Rust, and more.

🆚 Claude Code CLI vs Claude Code Web vs claude.ai - What's the difference?

Claude Code CLI: Terminal-based tool with direct file system access, runs commands locally, full control over your development environment. Best for deep integration with your local workflow.

Claude Code Web (NEW): Browser-based coding agent running on Anthropic's cloud infrastructure. Connects to GitHub repos, runs multiple tasks in parallel, generates PRs automatically. Best for delegating tasks, bug backlogs, and parallel development. Available at claude.com/code.

claude.ai: General web interface for conversations and non-coding tasks. Requires copy-pasting code, no direct repo access.

When to use what:

• CLI: Active development, local testing, complex workflows
• Web: Delegating tasks, parallel work across repos, mobile access
• claude.ai: General questions, brainstorming, non-coding tasks

Can't find your issue? Here's how to get help:

1. Search Documentation: Official Claude Code Docs
2. Check GitHub Issues: Known issues and feature requests
3. Ask the Community: Anthropic Discord
4. Contact Support: Anthropic Support