Does Claude Code (the CLI tool) have any limits on CPU, GPU, or memory usage? Are there any resource constraints or limits documented for how Claude Code operates on the local machine?


Let me fetch the Claude Code documentation to check for any documented resource constraints.


WebFetch

Prompt: What are the CPU, GPU, or memory usage limits and resource constraints for Claude Code?


# null

# Claude Code Documentation Map

This is a comprehensive map of all Claude Code documentation pages with their headings, designed for easy navigation by LLMs.

> **Note:** This file is auto-generated by GitHub Actions. Do not edit manually.
> Last updated: 2026-01-10 23:15:24 UTC

## Document Structure

This map uses a hierarchical structure:

* **##** marks documentation groups (e.g., 'Getting started')
* **###** marks individual documentation pages
* **Nested bullets** show the heading structure within each page
* Each page title links to the full documentation

## Getting started

### [overview](https://code.claude.com/docs/en/overview.md)

* Get started in 30 seconds
* What Claude Code does for you
* Why developers love Claude Code
* Next steps
* Additional resources

### [quickstart](https://code.claude.com/docs/en/quickstart.md)

* Before you begin
* Step 1: Install Claude Code
* Step 2: Log in to your account
* Step 3: Start your first session
* Step 4: Ask your first question
* Step 5: Make your first code change
* Step 6: Use Git with Claude Code
* Step 7: Fix a bug or add a feature
* Step 8: Test out other common workflows
* Essential commands
* Pro tips for beginners
* What's next?
* Getting help

### [common-workflows](https://code.claude.com/docs/en/common-workflows.md)

* Understand new codebases
  * Get a quick codebase overview
  * Find relevant code
* Fix bugs efficiently
* Refactor code
* Use specialized subagents
* Use Plan Mode for safe code analysis
  * When to use Plan Mode
  * How to use Plan Mode
  * Example: Planning a complex refactor
  * Configure Plan Mode as default
* Work with tests
* Create pull requests
* Handle documentation
* Work with images
* Reference files and directories
* Use extended thinking (thinking mode)
  * Per-request thinking with `ultrathink`
  * How extended thinking token budgets work
* Resume previous conversations
  * Name your sessions
  * Use the session picker
* Run parallel Claude Code sessions with Git worktrees
* Use Claude as a unix-style utility
  * Add Claude to your verification process
  * Pipe in, pipe out
  * Control output format
* Create custom slash commands
  * Create project-specific commands
  * Add command arguments with \$ARGUMENTS
  * Create personal slash commands
* Ask Claude about its capabilities
  * Example questions
* Next steps

### [changelog](https://code.claude.com/docs/en/changelog.md)

* (No headings found)

## Outside of the terminal

### [claude-code-on-the-web](https://code.claude.com/docs/en/claude-code-on-the-web.md)

* What is Claude Code on the web?
* Who can use Claude Code on the web?
* Getting started
* How it works
* Moving tasks between web and terminal
  * From terminal to web
    * Tips for background tasks
  * From web to terminal
    * Requirements for teleporting
* Cloud environment
  * Default image
    * Checking available tools
    * Language-specific setups
    * Databases
  * Environment configuration
  * Dependency management
    * Local vs remote execution
    * Persisting environment variables
* Network access and security
  * Network policy
    * GitHub proxy
    * Security proxy
  * Access levels
  * Default allowed domains
    * Anthropic Services
    * Version Control
    * Container Registries
    * Cloud Platforms
    * Package Managers - JavaScript/Node
    * Package Managers - Python
    * Package Managers - Ruby
    * Package Managers - Rust
    * Package Managers - Go
    * Package Managers - JVM
    * Package Managers - Other Languages
    * Linux Distributions
    * Development Tools & Platforms
    * Cloud Services & Monitoring
    * Content Delivery & Mirrors
    * Schema & Configuration
  * Security best practices for customized network access
* Security and isolation
* Pricing and rate limits
* Limitations
* Best practices
* Related resources

### [desktop](https://code.claude.com/docs/en/desktop.md)

* Claude Code on desktop (Preview)
* Features
* Installation
* Using Git worktrees
  * Copying files ignored with `.gitignore`
  * Launch Claude Code on the web
* Bundled Claude Code version
* Environment configuration
  * Custom environment variables
* Enterprise configuration
* Related resources

### [chrome](https://code.claude.com/docs/en/chrome.md)

* What the integration enables
* Prerequisites
* How the integration works
* Set up the integration
* Try it out
* Example workflows
  * Test a local web application
  * Debug with console logs
  * Automate form filling
  * Draft content in Google Docs
  * Extract data from web pages
  * Run multi-site workflows
  * Record a demo GIF
* Best practices
* Troubleshooting
  * Extension not detected
  * Browser not responding
  * First-time setup
* Enable by default
* See also

### [vs-code](https://code.claude.com/docs/en/vs-code.md)

* Prerequisites
* Install the extension
* Get started
* Customize your workflow
  * Change the layout
  * Switch to terminal mode
* VS Code commands and shortcuts
* Configure settings
* Use third-party providers
* VS Code extension vs. Claude Code CLI
  * Run CLI in VS Code
  * Switch between extension and CLI
* Security considerations
* Fix common issues
  * Extension won't install
  * Spark icon not visible
  * Claude Code never responds
  * Standalone CLI not connecting to IDE
* Uninstall the extension
* Next steps

### [jetbrains](https://code.claude.com/docs/en/jetbrains.md)

* Supported IDEs
* Features
* Installation
  * Marketplace Installation
* Usage
  * From Your IDE
  * From External Terminals
* Configuration
  * Claude Code Settings
  * Plugin Settings
    * General Settings
    * ESC Key Configuration
* Special Configurations
  * Remote Development
  * WSL Configuration
* Troubleshooting
  * Plugin Not Working
  * IDE Not Detected
  * Command Not Found
* Security Considerations

### [github-actions](https://code.claude.com/docs/en/github-actions.md)

* Why use Claude Code GitHub Actions?
* What can Claude do?
  * Claude Code Action
* Setup
* Quick setup
* Manual setup
* Upgrading from Beta
  * Essential changes
  * Breaking Changes Reference
  * Before and After Example
* Example use cases
  * Basic workflow
  * Using slash commands
  * Custom automation with prompts
  * Common use cases
* Best practices
  * CLAUDE.md configuration
  * Security considerations
  * Optimizing performance
  * CI costs
* Configuration examples
* Using with AWS Bedrock & Google Vertex AI
  * Prerequisites
    * For Google Cloud Vertex AI:
    * For AWS Bedrock:
* Troubleshooting
  * Claude not responding to @claude commands
  * CI not running on Claude's commits
  * Authentication errors
* Advanced configuration
  * Action parameters
    * Pass CLI arguments
  * Alternative integration methods
  * Customizing Claude's behavior

### [gitlab-ci-cd](https://code.claude.com/docs/en/gitlab-ci-cd.md)

* Why use Claude Code with GitLab?
* How it works
* What can Claude do?
* Setup
  * Quick setup
  * Manual setup (recommended for production)
* Example use cases
  * Turn issues into MRs
  * Get implementation help
  * Fix bugs quickly
* Using with AWS Bedrock & Google Vertex AI
* Configuration examples
  * Basic .gitlab-ci.yml (Claude API)
  * AWS Bedrock job example (OIDC)
  * Google Vertex AI job example (Workload Identity Federation)
* Best practices
  * CLAUDE.md configuration
  * Security considerations
  * Optimizing performance
  * CI costs
* Security and governance
* Troubleshooting
  * Claude not responding to @claude commands
  * Job can't write comments or open MRs
  * Authentication errors
* Advanced configuration
  * Common parameters and variables
  * Customizing Claude's behavior

### [slack](https://code.claude.com/docs/en/slack.md)

* Use cases
* Prerequisites
* Setting up Claude Code in Slack
* How it works
  * Automatic detection
  * Context gathering
  * Session flow
* User interface elements
  * App Home
  * Message actions
  * Repository selection
* Access and permissions
  * User-level access
  * Workspace admin permissions
* What's accessible where
* Best practices
  * Writing effective requests
  * When to use Slack vs. web
* Troubleshooting
  * Sessions not starting
  * Repository not showing
  * Wrong repository selected
  * Authentication errors
  * Session expiration
* Current limitations
* Related resources

## Build with Claude Code

### [sub-agents](https://code.claude.com/docs/en/sub-agents.md)

* Built-in subagents
* Quickstart: create your first subagent
* Configure subagents
  * Use the /agents command
  * Choose the subagent scope
  * Write subagent files
    * Supported frontmatter fields
  * Choose a model
  * Control subagent capabilities
    * Available tools
    * Permission modes
    * Conditional rules with hooks
    * Disable specific subagents
  * Define hooks for subagents
    * Hooks in subagent frontmatter
    * Project-level hooks for subagent events
* Work with subagents
  * Understand automatic delegation
  * Run subagents in foreground or background
  * Common patterns
    * Isolate high-volume operations
    * Run parallel research
    * Chain subagents
  * Choose between subagents and main conversation
  * Manage subagent context
    * Resume subagents
    * Auto-compaction
* Example subagents
  * Code reviewer
  * Debugger
  * Data scientist
  * Database query validator
* Next steps

### [plugins](https://code.claude.com/docs/en/plugins.md)

* When to use plugins vs standalone configuration
* Quickstart
  * Prerequisites
  * Create your first plugin
* Hello Command
* Hello Command
  * Plugin structure overview
  * Develop more complex plugins
    * Add Skills to your plugin
    * Add LSP servers to your plugin
    * Organize complex plugins
    * Test your plugins locally
    * Debug plugin issues
    * Share your plugins
  * Convert existing configurations to plugins
    * Migration steps
    * What changes when migrating
  * Next steps
    * For plugin users
    * For plugin developers

### [discover-plugins](https://code.claude.com/docs/en/discover-plugins.md)

* How marketplaces work
* Official Anthropic marketplace
  * Code intelligence
  * External integrations
  * Development workflows
  * Output styles
* Try it: add the demo marketplace
* Add marketplaces
  * Add from GitHub
  * Add from other Git hosts
  * Add from local paths
* Install plugins
* Manage installed plugins
* Manage marketplaces
  * Use the interactive interface
  * Use CLI commands
  * Configure auto-updates
* Configure team marketplaces
* Troubleshooting
  * /plugin command not recognized
  * Common issues
* Next steps

### [skills](https://code.claude.com/docs/en/skills.md)

* Create your first Skill
* How Skills work
  * Where Skills live
  * When to use Skills versus other options
* Configure Skills
  * Write SKILL.md
    * Available metadata fields
  * Update or delete a Skill
  * Add supporting files with progressive disclosure
    * Example: multi-file Skill structure
  * Restrict tool access with allowed-tools
  * Run Skills in a forked context
  * Define hooks for Skills
  * Control Skill visibility
    * When to use each setting
    * Example: model-only Skill
  * Skills and subagents
    * Give a subagent access to Skills
    * Run a Skill in a subagent context
  * Distribute Skills
* Examples
  * Simple Skill (single file)
  * Use multiple files
* Troubleshooting
  * View and test Skills
  * Skill not triggering
  * Skill doesn't load
  * Skill has errors
  * Multiple Skills conflict
  * Plugin Skills not appearing
* Next steps

### [output-styles](https://code.claude.com/docs/en/output-styles.md)

* Built-in output styles
* How output styles work
* Change your output style
* Create a custom output style
  * Frontmatter
* Comparisons to related features
  * Output Styles vs. CLAUDE.md vs. --append-system-prompt
  * Output Styles vs. [Agents](/en/sub-agents)
  * Output Styles vs. [Custom Slash Commands](/en/slash-commands)

### [hooks-guide](https://code.claude.com/docs/en/hooks-guide.md)

* Hook Events Overview
* Quickstart
  * Prerequisites
  * Step 1: Open hooks configuration
  * Step 2: Add a matcher
  * Step 3: Add the hook
  * Step 4: Save your configuration
  * Step 5: Verify your hook
  * Step 6: Test your hook
* More Examples
  * Code Formatting Hook
  * Markdown Formatting Hook
  * Custom Notification Hook
  * File Protection Hook
* Learn more

### [headless](https://code.claude.com/docs/en/headless.md)

* Basic usage
* Examples
  * Get structured output
  * Auto-approve tools
  * Create a commit
  * Customize the system prompt
  * Continue conversations
* Next steps

### [mcp](https://code.claude.com/docs/en/mcp.md)

* What you can do with MCP
* Popular MCP servers
* Installing MCP servers
  * Option 1: Add a remote HTTP server
  * Option 2: Add a remote SSE server
  * Option 3: Add a local stdio server
  * Managing your servers
  * Dynamic tool updates
  * Plugin-provided MCP servers
* MCP installation scopes
  * Local scope
  * Project scope
  * User scope
  * Choosing the right scope
  * Scope hierarchy and precedence
  * Environment variable expansion in `.mcp.json`
* Practical examples
  * Example: Monitor errors with Sentry
  * Example: Connect to GitHub for code reviews
  * Example: Query your PostgreSQL database
* Authenticate with remote MCP servers
* Add MCP servers from JSON configuration
* Import MCP servers from Claude Desktop
* Use Claude Code as an MCP server
* MCP output limits and warnings
* Use MCP resources
  * Reference MCP resources
* Use MCP prompts as slash commands
  * Execute MCP prompts
* Managed MCP configuration
  * Option 1: Exclusive control with managed-mcp.json
  * Option 2: Policy-based control with allowlists and denylists
    * Restriction options
    * Example configuration
    * How command-based restrictions work
    * How URL-based restrictions work
    * Allowlist behavior (`allowedMcpServers`)
    * Denylist behavior (`deniedMcpServers`)
    * Important notes

### [troubleshooting](https://code.claude.com/docs/en/troubleshooting.md)

* Common installation issues
  * Windows installation issues: errors in WSL
  * Linux and Mac installation issues: permission or command not found errors
    * Recommended solution: Native Claude Code installation
  * Windows: "Claude Code on Windows requires git-bash"
  * Windows: "installMethod is native, but claude command not found"
* Permissions and authentication
  * Repeated permission prompts
  * Authentication issues
* Configuration file locations
  * Resetting configuration
* Performance and stability
  * High CPU or memory usage
  * Command hangs or freezes
  * Search and discovery issues
  * Slow or incomplete search results on WSL
* IDE integration issues
  * JetBrains IDE not detected on WSL2
    * WSL2 networking modes
  * Reporting Windows IDE integration issues (both native and WSL)
  * Escape key not working in JetBrains (IntelliJ, PyCharm, etc.) terminals
* Markdown formatting issues
  * Missing language tags in code blocks
  * Inconsistent spacing and formatting
  * Best practices for markdown generation
* Getting more help

## Deployment

### [third-party-integrations](https://code.claude.com/docs/en/third-party-integrations.md)

* Compare deployment options
* Configure proxies and gateways
  * Amazon Bedrock
  * Microsoft Foundry
  * Google Vertex AI
* Best practices for organizations
  * Invest in documentation and memory
  * Simplify deployment
  * Start with guided usage
  * Configure security policies
  * Leverage MCP for integrations
* Next steps

### [amazon-bedrock](https://code.claude.com/docs/en/amazon-bedrock.md)

* Prerequisites
* Setup
  * 1. Submit use case details
  * 2. Configure AWS credentials
    * Advanced credential configuration
      * Example configuration
      * Configuration settings explained
  * 3. Configure Claude Code
  * 4. Model configuration
  * 5. Output token configuration
* IAM configuration
* Troubleshooting
* Additional resources

### [google-vertex-ai](https://code.claude.com/docs/en/google-vertex-ai.md)

* Prerequisites
* Region Configuration
* Setup
  * 1. Enable Vertex AI API
  * 2. Request model access
  * 3. Configure GCP credentials
  * 4. Configure Claude Code
  * 5. Model configuration
* IAM configuration
* 1M token context window
* Troubleshooting
* Additional resources

### [microsoft-foundry](https://code.claude.com/docs/en/microsoft-foundry.md)

* Prerequisites
* Setup
  * 1. Provision Microsoft Foundry resource
  * 2. Configure Azure credentials
  * 3. Configure Claude Code
* Azure RBAC configuration
* Troubleshooting
* Additional resources

### [network-config](https://code.claude.com/docs/en/network-config.md)

* Proxy configuration
  * Environment variables
  * Basic authentication
* Custom CA certificates
* mTLS authentication
* Network access requirements
* Additional resources

### [llm-gateway](https://code.claude.com/docs/en/llm-gateway.md)

* Gateway requirements
* Configuration
  * Model selection
* LiteLLM configuration
  * Prerequisites
  * Basic LiteLLM setup
    * Authentication methods
      * Static API key
      * Dynamic API key with helper
    * Unified endpoint (recommended)
    * Provider-specific pass-through endpoints (alternative)
      * Claude API through LiteLLM
      * Amazon Bedrock through LiteLLM
      * Google Vertex AI through LiteLLM
* Additional resources

### [devcontainer](https://code.claude.com/docs/en/devcontainer.md)

* Key features
* Getting started in 4 steps
* Configuration breakdown
* Security features
* Customization options
* Example use cases
  * Secure client work
  * Team onboarding
  * Consistent CI/CD environments
* Related resources

### [sandboxing](https://code.claude.com/docs/en/sandboxing.md)

* Overview
* Why sandboxing matters
* How it works
  * Filesystem isolation
  * Network isolation
  * OS-level enforcement
* Getting started
  * Enable sandboxing
  * Sandbox modes
  * Configure sandboxing
* Security benefits
  * Protection against prompt injection
  * Reduced attack surface
  * Transparent operation
* Security Limitations
* Advanced usage
  * Custom proxy configuration
  * Integration with existing security tools
* Best practices
* Open source
* Limitations
* See also

## Administration

### [setup](https://code.claude.com/docs/en/setup.md)

* System requirements
  * Additional dependencies
* Standard installation
* Windows setup
* Alternative installation methods
  * Native installation options
  * NPM installation
* Authentication options
  * For individuals
  * For teams and organizations
* Running on AWS or GCP
* Update Claude Code
  * Auto updates
  * Update manually
* Uninstall Claude Code
  * Native installation
  * Homebrew installation
  * NPM installation
  * Clean up configuration files (optional)

### [iam](https://code.claude.com/docs/en/iam.md)

* Authentication methods
  * Claude for Teams or Enterprise (recommended)
  * Claude Console authentication
  * Cloud provider authentication
* Access control and permissions
  * Permission system
  * Configuring permissions
    * Permission modes
    * Working directories
    * Tool-specific permission rules
  * Additional permission control with hooks
  * Managed settings
  * Settings precedence
* Credential management

### [security](https://code.claude.com/docs/en/security.md)

* How we approach security
  * Security foundation
  * Permission-based architecture
  * Built-in protections
  * User responsibility
* Protect against prompt injection
  * Core protections
  * Privacy safeguards
  * Additional safeguards
* MCP security
* IDE security
* Cloud execution security
* Security best practices
  * Working with sensitive code
  * Team security
  * Reporting security issues
* Related resources

### [data-usage](https://code.claude.com/docs/en/data-usage.md)

* Data policies
  * Data training policy
  * Development Partner Program
  * Feedback using the `/bug` command
  * Session quality surveys
  * Data retention
* Data access
* Local Claude Code: Data flow and dependencies
  * Cloud execution: Data flow and dependencies
* Telemetry services
* Default behaviors by API provider

### [monitoring-usage](https://code.claude.com/docs/en/monitoring-usage.md)

* Quick start
* Administrator configuration
* Configuration details
  * Common configuration variables
  * Metrics cardinality control
  * Dynamic headers
    * Settings configuration
    * Script requirements
    * Refresh behavior
  * Multi-team organization support
  * Example configurations
* Available metrics and events
  * Standard attributes
  * Metrics
  * Metric details
    * Session counter
    * Lines of code counter
    * Pull request counter
    * Commit counter
    * Cost counter
    * Token counter
    * Code edit tool decision counter
    * Active time counter
  * Events
    * User prompt event
    * Tool result event
    * API request event
    * API error event
    * Tool decision event
* Interpreting metrics and events data
  * Usage monitoring
  * Cost monitoring
  * Alerting and segmentation
  * Event analysis
* Backend considerations
  * For metrics
  * For events/logs
* Service information
* ROI measurement resources
* Security/privacy considerations
* Monitoring Claude Code on Amazon Bedrock

### [costs](https://code.claude.com/docs/en/costs.md)

* Track your costs
  * Using the `/cost` command
  * Additional tracking options
* Managing costs for teams
  * Rate limit recommendations
* Reduce token usage
* Background token usage
* Tracking version changes and updates
  * Current version information
  * Understanding changes in Claude Code behavior
  * When cost reporting changes

### [analytics](https://code.claude.com/docs/en/analytics.md)

* Access analytics
  * Required roles
* Available metrics
  * Lines of code accepted
  * Suggestion accept rate
  * Activity
  * Spend
  * Team insights
* Using analytics effectively
  * Monitor adoption
  * Measure productivity
* Related resources

### [plugin-marketplaces](https://code.claude.com/docs/en/plugin-marketplaces.md)

* Overview
* Walkthrough: create a local marketplace
* Create the marketplace file
* Marketplace schema
  * Required fields
  * Owner fields
  * Optional metadata
* Plugin entries
  * Required fields
  * Optional plugin fields
* Plugin sources
  * Relative paths
  * GitHub repositories
  * Git repositories
  * Advanced plugin entries
* Host and distribute marketplaces
  * Host on GitHub (recommended)
  * Host on other git services
  * Test locally before distribution
  * Require marketplaces for your team
  * Managed marketplace restrictions
    * Common configurations
    * How restrictions work
* Validation and testing
* Troubleshooting
  * Marketplace not loading
  * Marketplace validation errors
  * Plugin installation failures
  * Files not found after installation
* See also

## Configuration

### [settings](https://code.claude.com/docs/en/settings.md)

* Configuration scopes
  * Available scopes
  * When to use each scope
  * How scopes interact
  * What uses scopes
* Settings files
  * Available settings
  * Permission settings
  * Sandbox settings
  * Attribution settings
  * File suggestion settings
  * Hook configuration
  * Settings precedence
  * Key points about the configuration system
  * System prompt
  * Excluding sensitive files
* Subagent configuration
* Plugin configuration
  * Plugin settings
    * `enabledPlugins`
    * `extraKnownMarketplaces`
    * `strictKnownMarketplaces`
  * Managing plugins
* Environment variables
* Tools available to Claude
  * Bash tool behavior
  * Extending tools with hooks
* See also

### [terminal-config](https://code.claude.com/docs/en/terminal-config.md)

* Themes and appearance
* Line breaks
* Notification setup
  * iTerm 2 system notifications
  * Custom notification hooks
* Handling large inputs
* Vim Mode

### [model-config](https://code.claude.com/docs/en/model-config.md)

* Available models
  * Model aliases
  * Setting your model
* Special model behavior
  * `default` model setting
  * `opusplan` model setting
  * Extended context with \[1m]
* Checking your current model
* Environment variables
  * Prompt caching configuration

### [memory](https://code.claude.com/docs/en/memory.md)

* Determine memory type
* CLAUDE.md imports
* How Claude looks up memories
* Directly edit memories with `/memory`
* Set up project memory
* Modular rules with `.claude/rules/`
  * Basic structure
  * Path-specific rules
  * Glob patterns
  * Subdirectories
  * Symlinks
  * User-level rules
* Organization-level memory management
* Memory best practices

### [statusline](https://code.claude.com/docs/en/statusline.md)

* Create a custom status line
* How it Works
* JSON Input Structure
* Example Scripts
  * Simple Status Line
  * Git-Aware Status Line
  * Python Example
  * Node.js Example
  * Helper Function Approach
  * Context Window Usage
* Tips
* Troubleshooting

## Reference

### [cli-reference](https://code.claude.com/docs/en/cli-reference.md)

* CLI commands
* CLI flags
  * Agents flag format
  * System prompt flags
* See also

### [interactive-mode](https://code.claude.com/docs/en/interactive-mode.md)

* Keyboard shortcuts
  * General controls
  * Text editing
  * Theme and display
  * Multiline input
  * Quick commands
* Vim editor mode
  * Mode switching
  * Navigation (NORMAL mode)
  * Editing (NORMAL mode)
  * Text objects (NORMAL mode)
* Command history
  * Reverse search with Ctrl+R
* Background bash commands
  * How backgrounding works
  * Bash mode with `!` prefix
* See also

### [slash-commands](https://code.claude.com/docs/en/slash-commands.md)

* Built-in slash commands
* Custom slash commands
  * Syntax
    * Parameters
  * Command types
    * Project commands
    * Personal commands
  * Features
    * Namespacing
    * Arguments
      * All arguments with `$ARGUMENTS`
      * Individual arguments with `$1`, `$2`, etc.
    * Bash command execution
    * File references
    * Thinking mode
  * Frontmatter
    * Define hooks for commands
* Plugin commands
  * How plugin commands work
  * Plugin command structure
  * Invocation patterns
* MCP slash commands
  * Command format
  * Features
    * Dynamic discovery
    * Arguments
    * Naming conventions
  * Managing MCP connections
  * MCP permissions and wildcards
* `Skill` tool
  * What the `Skill` tool can invoke
  * Encourage Claude to use specific commands
  * Disable the `Skill` tool
  * Disable specific commands or Skills
  * `Skill` permission rules
  * Character budget limit
* Skills vs slash commands
  * Use slash commands for
  * Use Skills for
  * Key differences
  * Example comparison
  * When to use each
* See also

### [checkpointing](https://code.claude.com/docs/en/checkpointing.md)

* How checkpoints work
  * Automatic tracking
  * Rewinding changes
* Common use cases
* Limitations
  * Bash command changes not tracked
  * External changes not tracked
  * Not a replacement for version control
* See also

### [hooks](https://code.claude.com/docs/en/hooks.md)

* Configuration
  * Structure
  * Project-Specific Hook Scripts
  * Plugin hooks
  * Hooks in Skills, Agents, and Slash Commands
* Prompt-Based Hooks
  * How prompt-based hooks work
  * Configuration
  * Response schema
  * Supported hook events
  * Example: Intelligent Stop hook
  * Example: SubagentStop with custom logic
  * Comparison with bash command hooks
  * Best practices
* Hook Events
  * PreToolUse
  * PermissionRequest
  * PostToolUse
  * Notification
  * UserPromptSubmit
  * Stop
  * SubagentStop
  * PreCompact
  * SessionStart
    * Persisting environment variables
  * SessionEnd
* Hook Input
  * PreToolUse Input
    * Bash tool
    * Write tool
    * Edit tool
    * Read tool
  * PostToolUse Input
  * Notification Input
  * UserPromptSubmit Input
  * Stop and SubagentStop Input
  * PreCompact Input
  * SessionStart Input
  * SessionEnd Input
* Hook Output
  * Simple: Exit Code
    * Exit Code 2 Behavior
  * Advanced: JSON Output
    * Common JSON Fields
    * `PreToolUse` Decision Control
    * `PermissionRequest` Decision Control
    * `PostToolUse` Decision Control
    * `UserPromptSubmit` Decision Control
    * `Stop`/`SubagentStop` Decision Control
    * `SessionStart` Decision Control
    * `SessionEnd` Decision Control
    * Exit Code Example: Bash Command Validation
    * JSON Output Example: UserPromptSubmit to Add Context and Validation
    * JSON Output Example: PreToolUse with Approval
* Working with MCP Tools
  * MCP Tool Naming
  * Configuring Hooks for MCP Tools
* Examples
* Security Considerations
  * Disclaimer
  * Security Best Practices
  * Configuration Safety
* Hook Execution Details
* Debugging
  * Basic Troubleshooting
  * Advanced Debugging
  * Debug Output Example

### [plugins-reference](https://code.claude.com/docs/en/plugins-reference.md)

* Plugin components reference
  * Commands
  * Agents
  * Skills
  * Hooks
  * MCP servers
  * LSP servers
* Plugin installation scopes
* Plugin manifest schema
  * Complete schema
  * Required fields
  * Metadata fields
  * Component path fields
  * Path behavior rules
  * Environment variables
* Plugin caching and file resolution
  * How plugin caching works
  * Path traversal limitations
  * Working with external dependencies
* Plugin directory structure
  * Standard plugin layout
  * File locations reference
* CLI commands reference
  * plugin install
  * plugin uninstall
  * plugin enable
  * plugin disable
  * plugin update
* Debugging and development tools
  * Debugging commands
  * Common issues
  * Example error messages
  * Hook troubleshooting
  * MCP server troubleshooting
  * Directory structure mistakes
* Distribution and versioning reference
  * Version management
* See also

## Resources

### [legal-and-compliance](https://code.claude.com/docs/en/legal-and-compliance.md)

* Legal agreements
  * License
  * Commercial agreements
* Compliance
  * Healthcare compliance (BAA)
* Security and trust
  * Trust and safety
  * Security vulnerability reporting

---

> To find navigation and other pages in this documentation, fetch the llms.txt file at: https://code.claude.com/docs/llms.txt


Now let me check the troubleshooting page for any specific information about resource constraints.


Prompt: What are the CPU, memory, and GPU resource limits or constraints for Claude Code? Are there performance issues related to resource usage?


# Troubleshooting

> Discover solutions to common issues with Claude Code installation and usage.

## Common installation issues

### Windows installation issues: errors in WSL

You might encounter the following issues in WSL:

**OS/platform detection issues**: If you receive an error during installation, WSL may be using Windows `npm`. Try:

* Run `npm config set os linux` before installation
* Install with `npm install -g @anthropic-ai/claude-code --force --no-os-check` (Do NOT use `sudo`)

**Node not found errors**: If you see `exec: node: not found` when running `claude`, your WSL environment may be using a Windows installation of Node.js. You can confirm this with `which npm` and `which node`, which should point to Linux paths starting with `/usr/` rather than `/mnt/c/`. To fix this, try installing Node via your Linux distribution's package manager or via [`nvm`](https://github.com/nvm-sh/nvm).

**nvm version conflicts**: If you have nvm installed in both WSL and Windows, you may experience version conflicts when switching Node versions in WSL. This happens because WSL imports the Windows PATH by default, causing Windows nvm/npm to take priority over the WSL installation.

You can identify this issue by:

* Running `which npm` and `which node` - if they point to Windows paths (starting with `/mnt/c/`), Windows versions are being used
* Experiencing broken functionality after switching Node versions with nvm in WSL

To resolve this issue, fix your Linux PATH to ensure the Linux node/npm versions take priority:

**Primary solution: Ensure nvm is properly loaded in your shell**

The most common cause is that nvm isn't loaded in non-interactive shells. Add the following to your shell configuration file (`~/.bashrc`, `~/.zshrc`, etc.):

```bash  theme={null}
# Load nvm if it exists
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
```

Or run directly in your current session:

```bash  theme={null}
source ~/.nvm/nvm.sh
```

**Alternative: Adjust PATH order**

If nvm is properly loaded but Windows paths still take priority, you can explicitly prepend your Linux paths to PATH in your shell configuration:

```bash  theme={null}
export PATH="$HOME/.nvm/versions/node/$(node -v)/bin:$PATH"
```

<Warning>
  Avoid disabling Windows PATH importing (`appendWindowsPath = false`) as this breaks the ability to call Windows executables from WSL. Similarly, avoid uninstalling Node.js from Windows if you use it for Windows development.
</Warning>

### Linux and Mac installation issues: permission or command not found errors

When installing Claude Code with npm, `PATH` problems may prevent access to `claude`.
You may also encounter permission errors if your npm global prefix is not user writable (for example, `/usr`, or `/usr/local`).

#### Recommended solution: Native Claude Code installation

Claude Code has a native installation that doesn't depend on npm or Node.js.

Use the following command to run the native installer.

**macOS, Linux, WSL:**

```bash  theme={null}
# Install stable version (default)
curl -fsSL https://claude.ai/install.sh | bash

# Install latest version
curl -fsSL https://claude.ai/install.sh | bash -s latest

# Install specific version number
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58
```

**Windows PowerShell:**

```powershell  theme={null}
# Install stable version (default)
irm https://claude.ai/install.ps1 | iex

# Install latest version
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) latest

# Install specific version number
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 1.0.58

```

This command installs the appropriate build of Claude Code for your operating system and architecture and adds a symlink to the installation at `~/.local/bin/claude` (or `%USERPROFILE%\.local\bin\claude.exe` on Windows).

<Tip>
  Make sure that you have the installation directory in your system PATH.
</Tip>

### Windows: "Claude Code on Windows requires git-bash"

Claude Code on native Windows requires [Git for Windows](https://git-scm.com/downloads/win) which includes Git Bash. If Git is installed but not detected:

1. Set the path explicitly in PowerShell before running Claude:
   ```powershell  theme={null}
   $env:CLAUDE_CODE_GIT_BASH_PATH="C:\Program Files\Git\bin\bash.exe"
   ```

2. Or add it to your system environment variables permanently through System Properties → Environment Variables.

If Git is installed in a non-standard location, adjust the path accordingly.

### Windows: "installMethod is native, but claude command not found"

If you see this error after installation, the `claude` command isn't in your PATH. Add it manually:

<Steps>
  <Step title="Open Environment Variables">
    Press `Win + R`, type `sysdm.cpl`, and press Enter. Click **Advanced** → **Environment Variables**.
  </Step>

  <Step title="Edit User PATH">
    Under "User variables", select **Path** and click **Edit**. Click **New** and add:

    ```
    %USERPROFILE%\.local\bin
    ```
  </Step>

  <Step title="Restart your terminal">
    Close and reopen PowerShell or CMD for changes to take effect.
  </Step>
</Steps>

Verify installation:

```bash  theme={null}
claude doctor # Check installation health
```

## Permissions and authentication

### Repeated permission prompts

If you find yourself repeatedly approving the same commands, you can allow specific tools
to run without approval using the `/permissions` command. See [Permissions docs](/en/iam#configuring-permissions).

### Authentication issues

If you're experiencing authentication problems:

1. Run `/logout` to sign out completely
2. Close Claude Code
3. Restart with `claude` and complete the authentication process again

If problems persist, try:

```bash  theme={null}
rm -rf ~/.config/claude-code/auth.json
claude
```

This removes your stored authentication information and forces a clean login.

## Configuration file locations

Claude Code stores configuration in several locations:

| File                          | Purpose                                                  |
| :---------------------------- | :------------------------------------------------------- |
| `~/.claude/settings.json`     | User settings (permissions, hooks, model overrides)      |
| `.claude/settings.json`       | Project settings (checked into source control)           |
| `.claude/settings.local.json` | Local project settings (not committed)                   |
| `~/.claude.json`              | Global state (theme, OAuth, MCP servers, allowed tools)  |
| `.mcp.json`                   | Project MCP servers (checked into source control)        |
| `managed-settings.json`       | [Managed settings](/en/settings#settings-files)          |
| `managed-mcp.json`            | [Managed MCP servers](/en/mcp#managed-mcp-configuration) |

On Windows, `~` refers to your user home directory, such as `C:\Users\YourName`.

**Managed file locations:**

* macOS: `/Library/Application Support/ClaudeCode/`
* Linux/WSL: `/etc/claude-code/`
* Windows: `C:\Program Files\ClaudeCode\`

For details on configuring these files, see [Settings](/en/settings) and [MCP](/en/mcp).

### Resetting configuration

To reset Claude Code to default settings, you can remove the configuration files:

```bash  theme={null}
# Reset all user settings and state
rm ~/.claude.json
rm -rf ~/.claude/

# Reset project-specific settings
rm -rf .claude/
rm .mcp.json
```

<Warning>
  This will remove all your settings, allowed tools, MCP server configurations, and session history.
</Warning>

## Performance and stability

### High CPU or memory usage

Claude Code is designed to work with most development environments, but may consume significant resources when processing large codebases. If you're experiencing performance issues:

1. Use `/compact` regularly to reduce context size
2. Close and restart Claude Code between major tasks
3. Consider adding large build directories to your `.gitignore` file

### Command hangs or freezes

If Claude Code seems unresponsive:

1. Press Ctrl+C to attempt to cancel the current operation
2. If unresponsive, you may need to close the terminal and restart

### Search and discovery issues

If Search tool, `@file` mentions, custom agents, and custom slash commands aren't working, install system `ripgrep`:

```bash  theme={null}
# macOS (Homebrew)
brew install ripgrep

# Windows (winget)
winget install BurntSushi.ripgrep.MSVC

# Ubuntu/Debian
sudo apt install ripgrep

# Alpine Linux
apk add ripgrep

# Arch Linux
pacman -S ripgrep
```

Then set `USE_BUILTIN_RIPGREP=0` in your [environment](/en/settings#environment-variables).

### Slow or incomplete search results on WSL

Disk read performance penalties when [working across file systems on WSL](https://learn.microsoft.com/en-us/windows/wsl/filesystems) may result in fewer-than-expected matches (but not a complete lack of search functionality) when using Claude Code on WSL.

<Note>
  `/doctor` will show Search as OK in this case.
</Note>

**Solutions:**

1. **Submit more specific searches**: Reduce the number of files searched by specifying directories or file types: "Search for JWT validation logic in the auth-service package" or "Find use of md5 hash in JS files".

2. **Move project to Linux filesystem**: If possible, ensure your project is located on the Linux filesystem (`/home/`) rather than the Windows filesystem (`/mnt/c/`).

3. **Use native Windows instead**: Consider running Claude Code natively on Windows instead of through WSL, for better file system performance.

## IDE integration issues

### JetBrains IDE not detected on WSL2

If you're using Claude Code on WSL2 with JetBrains IDEs and getting "No available IDEs detected" errors, this is likely due to WSL2's networking configuration or Windows Firewall blocking the connection.

#### WSL2 networking modes

WSL2 uses NAT networking by default, which can prevent IDE detection. You have two options:

**Option 1: Configure Windows Firewall** (recommended)

1. Find your WSL2 IP address:
   ```bash  theme={null}
   wsl hostname -I
   # Example output: 172.21.123.456
   ```

2. Open PowerShell as Administrator and create a firewall rule:
   ```powershell  theme={null}
   New-NetFirewallRule -DisplayName "Allow WSL2 Internal Traffic" -Direction Inbound -Protocol TCP -Action Allow -RemoteAddress 172.21.0.0/16 -LocalAddress 172.21.0.0/16
   ```
   (Adjust the IP range based on your WSL2 subnet from step 1)

3. Restart both your IDE and Claude Code

**Option 2: Switch to mirrored networking**

Add to `.wslconfig` in your Windows user directory:

```ini  theme={null}
[wsl2]
networkingMode=mirrored
```

Then restart WSL with `wsl --shutdown` from PowerShell.

<Note>
  These networking issues only affect WSL2. WSL1 uses the host's network directly and doesn't require these configurations.
</Note>

For additional JetBrains configuration tips, see our [JetBrains IDE guide](/en/jetbrains#plugin-settings).

### Reporting Windows IDE integration issues (both native and WSL)

If you're experiencing IDE integration problems on Windows, [create an issue](https://github.com/anthropics/claude-code/issues) with the following information:

* Environment type: native Windows (Git Bash) or WSL1/WSL2
* WSL networking mode (if applicable): NAT or mirrored
* IDE name and version
* Claude Code extension/plugin version
* Shell type: Bash, Zsh, PowerShell, etc.

### Escape key not working in JetBrains (IntelliJ, PyCharm, etc.) terminals

If you're using Claude Code in JetBrains terminals and the `Esc` key doesn't interrupt the agent as expected, this is likely due to a keybinding clash with JetBrains' default shortcuts.

To fix this issue:

1. Go to Settings → Tools → Terminal
2. Either:
   * Uncheck "Move focus to the editor with Escape", or
   * Click "Configure terminal keybindings" and delete the "Switch focus to Editor" shortcut
3. Apply the changes

This allows the `Esc` key to properly interrupt Claude Code operations.

## Markdown formatting issues

Claude Code sometimes generates markdown files with missing language tags on code fences, which can affect syntax highlighting and readability in GitHub, editors, and documentation tools.

### Missing language tags in code blocks

If you notice code blocks like this in generated markdown:

````markdown  theme={null}
```
function example() {
  return "hello";
}
```
````

Instead of properly tagged blocks like:

````markdown  theme={null}
```javascript
function example() {
  return "hello";
}
```
````

**Solutions:**

1. **Ask Claude to add language tags**: Request "Add appropriate language tags to all code blocks in this markdown file."

2. **Use post-processing hooks**: Set up automatic formatting hooks to detect and add missing language tags. See the [markdown formatting hook example](/en/hooks-guide#markdown-formatting-hook) for implementation details.

3. **Manual verification**: After generating markdown files, review them for proper code block formatting and request corrections if needed.

### Inconsistent spacing and formatting

If generated markdown has excessive blank lines or inconsistent spacing:

**Solutions:**

1. **Request formatting corrections**: Ask Claude to "Fix spacing and formatting issues in this markdown file."

2. **Use formatting tools**: Set up hooks to run markdown formatters like `prettier` or custom formatting scripts on generated markdown files.

3. **Specify formatting preferences**: Include formatting requirements in your prompts or project [memory](/en/memory) files.

### Best practices for markdown generation

To minimize formatting issues:

* **Be explicit in requests**: Ask for "properly formatted markdown with language-tagged code blocks"
* **Use project conventions**: Document your preferred markdown style in [`CLAUDE.md`](/en/memory)
* **Set up validation hooks**: Use post-processing hooks to automatically verify and fix common formatting issues

## Getting more help

If you're experiencing issues not covered here:

1. Use the `/bug` command within Claude Code to report problems directly to Anthropic
2. Check the [GitHub repository](https://github.com/anthropics/claude-code) for known issues
3. Run `/doctor` to check the health of your Claude Code installation
4. Ask Claude directly about its capabilities and features - Claude has built-in access to its documentation

---

> To find navigation and other pages in this documentation, fetch the llms.txt file at: https://code.claude.com/docs/llms.txt


Let me also check the system requirements documentation for any hardware constraints.


Prompt: What are the system requirements and hardware constraints (CPU, memory, GPU) for Claude Code?


# Set up Claude Code

> Install, authenticate, and start using Claude Code on your development machine.

## System requirements

* **Operating Systems**: macOS 10.15+, Ubuntu 20.04+/Debian 10+, or Windows 10+ (with WSL 1, WSL 2, or Git for Windows)
* **Hardware**: 4 GB+ RAM
* **Software**: [Node.js 18+](https://nodejs.org/en/download) (only required for npm installation)
* **Network**: Internet connection required for authentication and AI processing
* **Shell**: Works best in Bash, Zsh or Fish
* **Location**: [Anthropic supported countries](https://www.anthropic.com/supported-countries)

### Additional dependencies

* **ripgrep**: Usually included with Claude Code. If search fails, see [search troubleshooting](/en/troubleshooting#search-and-discovery-issues).

## Standard installation

To install Claude Code, use one of the following methods:

<Tabs>
  <Tab title="Native Install (Recommended)">
    **macOS, Linux, WSL:**

    ```bash  theme={null}
    curl -fsSL https://claude.ai/install.sh | bash
    ```

    **Windows PowerShell:**

    ```powershell  theme={null}
    irm https://claude.ai/install.ps1 | iex
    ```

    **Windows CMD:**

    ```batch  theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
    ```
  </Tab>

  <Tab title="Homebrew">
    ```sh  theme={null}
    brew install --cask claude-code
    ```
  </Tab>

  <Tab title="NPM">
    If you have [Node.js 18 or newer installed](https://nodejs.org/en/download/):

    ```sh  theme={null}
    npm install -g @anthropic-ai/claude-code
    ```
  </Tab>
</Tabs>

<Note>
  Some users may be automatically migrated to an improved installation method.
</Note>

After the installation process completes, navigate to your project and start Claude Code:

```bash  theme={null}
cd your-awesome-project
claude
```

## Windows setup

**Option 1: Claude Code within WSL**

* Both WSL 1 and WSL 2 are supported

**Option 2: Claude Code on native Windows with Git Bash**

* Requires [Git for Windows](https://git-scm.com/downloads/win)
* For portable Git installations, specify the path to your `bash.exe`:
  ```powershell  theme={null}
  $env:CLAUDE_CODE_GIT_BASH_PATH="C:\Program Files\Git\bin\bash.exe"
  ```

## Alternative installation methods

Claude Code offers multiple installation methods to suit different environments.

If you encounter any issues during installation, consult the [troubleshooting guide](/en/troubleshooting#linux-permission-issues).

<Tip>
  Run `claude doctor` after installation to check your installation type and version.
</Tip>

### Native installation options

The native installation is the recommended method and offers several benefits:

* One self-contained executable
* No Node.js dependency
* Improved auto-updater stability

If you have an existing installation of Claude Code, use `claude install` to migrate to the native binary installation.

For advanced installation options with the native installer:

**macOS, Linux, WSL:**

```bash  theme={null}
# Install stable version (default)
curl -fsSL https://claude.ai/install.sh | bash

# Install latest version
curl -fsSL https://claude.ai/install.sh | bash -s latest

# Install specific version number
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58
```

<Note>
  **Alpine Linux and other musl/uClibc-based distributions**: The native build requires `libgcc`, `libstdc++`, and `ripgrep`. For Alpine: `apk add libgcc libstdc++ ripgrep`. Set `USE_BUILTIN_RIPGREP=0`.
</Note>

**Windows PowerShell:**

```powershell  theme={null}
# Install stable version (default)
irm https://claude.ai/install.ps1 | iex

# Install latest version
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) latest

# Install specific version number
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 1.0.58
```

**Windows CMD:**

```batch  theme={null}
REM Install stable version (default)
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

REM Install latest version
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd latest && del install.cmd

REM Install specific version number
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd 1.0.58 && del install.cmd
```

<Tip>
  Make sure that you remove any outdated aliases or symlinks before installing.
</Tip>

**Binary integrity and code signing**

* SHA256 checksums for all platforms are published in the release manifests, currently located at `https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/{VERSION}/manifest.json` (example: replace `{VERSION}` with `2.0.30`)
* Signed binaries are distributed for the following platforms:
  * macOS: Signed by "Anthropic PBC" and notarized by Apple
  * Windows: Signed by "Anthropic, PBC"

### NPM installation

For environments where NPM is preferred or required:

```sh  theme={null}
npm install -g @anthropic-ai/claude-code
```

<Warning>
  Do NOT use `sudo npm install -g` as this can lead to permission issues and security risks.
  If you encounter permission errors, see [configure Claude Code](/en/troubleshooting#linux-permission-issues) for recommended solutions.
</Warning>

## Authentication options

### For individuals

1. **Claude Pro or Max plan** (recommended): Subscribe to Claude's [Pro or Max plan](https://claude.ai/pricing) for a unified subscription that includes both Claude Code and Claude on the web. Manage your account in one place and log in with your Claude.ai account.
2. **Claude Console**: Connect through the [Claude Console](https://console.anthropic.com) and complete the OAuth process. Requires active billing in the Anthropic Console. A "Claude Code" workspace is automatically created for usage tracking and cost management. You can't create API keys for the Claude Code workspace; it's dedicated exclusively for Claude Code usage.

### For teams and organizations

1. **Claude for Teams or Enterprise** (recommended): Subscribe to [Claude for Teams](https://claude.com/pricing#team-&-enterprise) or [Claude for Enterprise](https://anthropic.com/contact-sales) for centralized billing, team management, and access to both Claude Code and Claude on the web. Team members log in with their Claude.ai accounts.
2. **Claude Console with team billing**: Set up a shared [Claude Console](https://console.anthropic.com) organization with team billing. Invite team members and assign roles for usage tracking.
3. **Cloud providers**: Configure Claude Code to use [Amazon Bedrock, Google Vertex AI, or Microsoft Foundry](/en/third-party-integrations) for deployments with your existing cloud infrastructure.

<Note>
  Claude Code securely stores your credentials. See [Credential Management](/en/iam#credential-management) for details.
</Note>

## Running on AWS or GCP

By default, Claude Code uses the Claude API.

For details on running Claude Code on AWS or GCP, see [third-party integrations](/en/third-party-integrations).

## Update Claude Code

### Auto updates

Claude Code automatically keeps itself up to date to ensure you have the latest features and security fixes.

* **Update checks**: Performed on startup and periodically while running
* **Update process**: Downloads and installs automatically in the background
* **Notifications**: You'll see a notification when updates are installed
* **Applying updates**: Updates take effect the next time you start Claude Code

**Disable auto-updates:**

Set the `DISABLE_AUTOUPDATER` environment variable in your shell or [settings.json file](/en/settings):

```bash  theme={null}
export DISABLE_AUTOUPDATER=1
```

### Update manually

```bash  theme={null}
claude update
```

## Uninstall Claude Code

If you need to uninstall Claude Code, follow the instructions for your installation method.

### Native installation

Remove the Claude Code binary and version files:

**macOS, Linux, WSL:**

```bash  theme={null}
rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude
```

**Windows PowerShell:**

```powershell  theme={null}
Remove-Item -Path "$env:USERPROFILE\.local\bin\claude.exe" -Force
Remove-Item -Path "$env:USERPROFILE\.local\share\claude" -Recurse -Force
```

**Windows CMD:**

```batch  theme={null}
del "%USERPROFILE%\.local\bin\claude.exe"
rmdir /s /q "%USERPROFILE%\.local\share\claude"
```

### Homebrew installation

```bash  theme={null}
brew uninstall --cask claude-code
```

### NPM installation

```bash  theme={null}
npm uninstall -g @anthropic-ai/claude-code
```

### Clean up configuration files (optional)

<Warning>
  Removing configuration files will delete all your settings, allowed tools, MCP server configurations, and session history.
</Warning>

To remove Claude Code settings and cached data:

**macOS, Linux, WSL:**

```bash  theme={null}
# Remove user settings and state
rm -rf ~/.claude
rm ~/.claude.json

# Remove project-specific settings (run from your project directory)
rm -rf .claude
rm -f .mcp.json
```

**Windows PowerShell:**

```powershell  theme={null}
# Remove user settings and state
Remove-Item -Path "$env:USERPROFILE\.claude" -Recurse -Force
Remove-Item -Path "$env:USERPROFILE\.claude.json" -Force

# Remove project-specific settings (run from your project directory)
Remove-Item -Path ".claude" -Recurse -Force
Remove-Item -Path ".mcp.json" -Force
```

**Windows CMD:**

```batch  theme={null}
REM Remove user settings and state
rmdir /s /q "%USERPROFILE%\.claude"
del "%USERPROFILE%\.claude.json"

REM Remove project-specific settings (run from your project directory)
rmdir /s /q ".claude"
del ".mcp.json"
```

---

> To find navigation and other pages in this documentation, fetch the llms.txt file at: https://code.claude.com/docs/llms.txt


Based on my review of the official Claude Code documentation, here's what I found about resource constraints:

## Resource Constraints for Claude Code

**Official documentation shows minimal documented limits:**

Claude Code does NOT have formally documented CPU, GPU, or strict memory limits in its official documentation. However, there is important information about resource usage:

### Hardware Requirements
- **Minimum**: 4 GB RAM (the only hardware requirement listed)
- **CPU & GPU**: No specific limits or recommendations documented
- **Operating Systems**: macOS 10.15+, Ubuntu 20.04+/Debian 10+, or Windows 10+

### Performance Considerations

From the troubleshooting documentation, Claude Code is noted to:

1. **Process large codebases with resource intensity**: The docs explicitly state "Claude Code is designed to work with most development environments, but may consume significant resources when processing large codebases."

2. **Recommended mitigations for resource-heavy operations:**
   - Use `/compact` regularly to reduce context size
   - Close and restart Claude Code between major tasks
   - Add large build directories to `.gitignore` to reduce search scope

### What This Means

While Claude Code doesn't enforce hard CPU, GPU, or memory limits, the design assumes:
- Resource usage scales with codebase size
- It's optimized for typical development workflows on systems with 4GB+ RAM
- Performance degrades gracefully on resource-constrained systems
- There are no GPU requirements (CPU-only operation)

If you need more specific resource constraints or want to suggest documentation improvements about resource limits, you can use `/feedback` to report this to Anthropic.

Sources:
- [Claude Code Setup - System Requirements](https://code.claude.com/docs/en/setup.md)
- [Claude Code Troubleshooting - Performance and Stability](https://code.claude.com/docs/en/troubleshooting.md)