SuperClaude Framework

https://superclaude.netlify.app/docs
Admin
SuperClaude Framework is a comprehensive system offering guides and resources for agents, commands,...
Tokens:34,092
Snippets:277
Trust Score:7.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### New Project Setup Workflow Example

Source: https://superclaude.netlify.app/docs/User-Guide/commands

Demonstrates a sequence of commands for setting up a new project, starting with discovery, moving to design, and finishing with a development roadmap.

```bash
# Define project requirements using brainstorm
/sc:brainstorm "project concept"

# Create a technical design for the system architecture
/sc:design "system architecture"

# Generate a development roadmap for implementation
/sc:workflow "implementation plan"
```

--------------------------------

### SuperClaude Installation Commands

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Various commands to install SuperClaude with different options, including guided setup, specific component installation, preview mode, forced installation, and listing available components.

```bash
SuperClaude install
SuperClaude install --components core mcp modes
SuperClaude install --dry-run
SuperClaude install --force --yes
SuperClaude install --list-components
```

--------------------------------

### Install SuperClaude using pipx, pip, or npm

Source: https://superclaude.netlify.app/docs/Getting-Started/quick-start

Provides commands to install the SuperClaude framework using different package managers. It ensures the framework is ready for use in the terminal or via npm.

```bash
# Quick install with pipx
pipx install SuperClaude && SuperClaude install

# Or traditional pip
pip install SuperClaude && SuperClaude install

# Or via npm
npm install -g @bifrost_inc/superclaude && superclaude install
```

--------------------------------

### Interact with Claude Code

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Example commands to use within Claude Code after installation. These commands demonstrate initiating brainstorming, analyzing files, and activating specific agents.

```bash
# Open Claude Code and try these commands:
/sc:brainstorm "test project"     # Should trigger discovery questions
/sc:analyze README.md              # Should provide structured analysis
@agent-security "review code"     # Should activate security specialist
```

--------------------------------

### Quick Start: Automatic Agent Coordination (Bash)

Source: https://superclaude.netlify.app/docs/User-Guide/agents

Demonstrates quick start examples for automatic agent coordination using the '/sc:' command prefix. These examples show how complex requests trigger multiple, specialized agents for tasks like implementing security features, designing dashboards, or troubleshooting deployment pipelines.

```bash
# Commands that trigger auto-activation
/sc:implement "JWT authentication with rate limiting"
# → Triggers: security-engineer + backend-architect + quality-engineer

/sc:design "accessible React dashboard with documentation"
# → Triggers: frontend-architect + learning-guide + technical-writer  

/sc:troubleshoot "slow deployment pipeline with intermittent failures"
```

--------------------------------

### Verify SuperClaude Installation

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Commands to check the installed SuperClaude version and list installed components. This helps confirm that the installation was successful and all expected components are present.

```bash
# Verify SuperClaude version
python3 -m SuperClaude --version
# Expected: SuperClaude 4.0.8

# List installed components
SuperClaude install --list-components
# Expected: List of available components
```

--------------------------------

### Test Node.js and MCP Server

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Verifies that Node.js is installed and functional, and tests the installation of the @context7/mcp-server package.

```bash
node -e "console.log('Node.js working')"
npm test @context7/mcp-server
```

--------------------------------

### Quick Start: Manual Agent Invocation (Bash)

Source: https://superclaude.netlify.app/docs/User-Guide/agents

Examples showcasing the quick start for manually invoking agents. This involves using the '@agent-' prefix to explicitly call agents like python-expert, quality-engineer, technical-writer, and socratic-mentor for specific tasks.

```bash
# Explicitly call specific agents with @agent- prefix
@agent-python-expert "optimize this data processing pipeline"
@agent-quality-engineer "create comprehensive test suite"
@agent-technical-writer "document this API with examples"
@agent-socratic-mentor "explain this design pattern"
```

--------------------------------

### Use SuperClaude commands in Claude Code

Source: https://superclaude.netlify.app/docs/Getting-Started/quick-start

Demonstrates how to interact with SuperClaude within Claude Code using special commands. These examples show how to initiate brainstorming, analyze code directories, generate implementations, and activate AI agents for specific tasks.

```text
# Interactive discovery
/sc:brainstorm "web app for task management"

# Analyze existing code
/sc:analyze src/

# Generate implementation
/sc:implement "user authentication"

# Activate specialist
@agent-security "review auth flow"
```

--------------------------------

### Code Quality Improvement Workflow Example

Source: https://superclaude.netlify.app/docs/User-Guide/commands

Shows a workflow for improving code quality, starting with analysis, previewing improvements, and validating with tests.

```bash
# Assess the current code quality
/sc:analyze --focus quality

# Preview potential code improvements
/sc:improve --preview

# Validate the applied improvements with tests and coverage
/sc:test --coverage
```

--------------------------------

### Install SuperClaude Framework Components (Python)

Source: https://superclaude.netlify.app/docs/Developer-Guide/testing-debugging

Installs SuperClaude framework components using Python. Ensure the PYTHONPATH is correctly set to the framework's location. This command is used for initial setup or updating specific components.

```bash
PYTHONPATH=/path/to/SuperClaude_Framework python3 -m setup install --components mcp --force
```

--------------------------------

### Development Installation of SuperClaude (Python)

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Sets up SuperClaude for development by cloning the repository and installing it in editable mode using pip. This allows for direct code modifications and testing.

```python
# Clone repository
git clone https://github.com/SuperClaude-Org/SuperClaude_Framework.git
cd SuperClaude_Framework

# Install in development mode
pip install -e ".[dev]"

# Test installation
SuperClaude install --dry-run
```

--------------------------------

### Install SuperClaude using pip (Python)

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Installs SuperClaude using pip, the standard Python package installer. This method is suitable for traditional Python setups and can be used for user-specific installations.

```python
# Standard installation
pip install SuperClaude

# Or user installation
pip install --user SuperClaude

# Run the installer
SuperClaude install
```

--------------------------------

### Standard Mode Example

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Presents a typical communication example for Standard Mode, showcasing a clear and professional approach to explaining the implementation of a login function with detailed steps and best practices.

```text
"I'll implement the login function with proper error handling:
 
 1. Validate user input (email format, password requirements)
 2. Authenticate against database with secure hashing
 3. Generate JWT token with appropriate expiration
 4. Return success response with user data
 
 The implementation will follow security best practices and include comprehensive error handling."
```

--------------------------------

### Install Python, pip, and venv on Linux

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Commands to install Python 3, pip, and venv on Ubuntu/Debian systems, which are prerequisites for installing SuperClaude.

```bash
sudo apt update
sudo apt install python3 python3-pip python3-venv
```

--------------------------------

### Verify SuperClaude Installation and Components

Source: https://superclaude.netlify.app/docs/Reference/troubleshooting

Commands to check the installed SuperClaude version and list its components. Useful for confirming successful installation or identifying missing parts.

```bash
python3 -m SuperClaude --version    # Should show 4.0.8
SuperClaude install --list-components
```

--------------------------------

### Feature Development Workflow Example

Source: https://superclaude.netlify.app/docs/User-Guide/commands

Illustrates the typical commands used for developing a new feature, including implementation, testing, and documentation generation.

```bash
# Implement the specified feature
/sc:implement "feature name"

# Validate the feature implementation with comprehensive tests
/sc:test --coverage

# Generate API documentation for the new feature
/sc:document --type api
```

--------------------------------

### Complete SuperClaude Reinstallation (Bash)

Source: https://superclaude.netlify.app/docs/Developer-Guide/testing-debugging

A script to perform a complete reinstallation of SuperClaude. It includes backing up the existing configuration, removing the old installation, and performing a fresh install using the framework setup.

```bash
# Backup existing configuration
cp -r ~/.claude ~/.claude.backup.$(date +%Y%m%d)

# Remove existing installation
rm -rf ~/.claude

# Reinstall everything
PYTHONPATH=/path/to/SuperClaude_Framework python3 -m setup install

# Restore any customizations from backup if needed

```

--------------------------------

### Troubleshoot Permission Denied Error

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Solutions for permission errors during SuperClaude installation. Options include using user installation, pipx, or sudo with caution.

```bash
# Use user installation
pip install --user SuperClaude

# Or use sudo (not recommended)
sudo pip install SuperClaude

# Better: use pipx
pipx install SuperClaude
```

--------------------------------

### Install Python on macOS

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Instructions for installing Python 3 on macOS using Homebrew, a common package manager for the platform.

```bash
# Install Homebrew first if needed
brew install python3
```

--------------------------------

### Agent Activation Examples (Bash)

Source: https://superclaude.netlify.app/docs/User-Guide/agents

Demonstrates how to use natural language prompts with specific keywords to trigger multiple SuperClaude agents for development and analysis tasks. These examples show optimized requests that lead to more comprehensive agent coordination.

```bash
# Generic (limited agent activation)
"Fix the login feature"

# Optimized (multi-agent coordination)  
"Implement secure JWT authentication with rate limiting and accessibility compliance"
# → Triggers: security-engineer + backend-architect + frontend-architect + quality-engineer
```

```bash
# Full-stack feature development
/sc:implement "responsive user dashboard with real-time notifications"
# → frontend-architect + backend-architect + performance-engineer

# API development with documentation
/sc:create "REST API for payment processing with comprehensive docs"  
# → backend-architect + security-engineer + technical-writer + quality-engineer

# Performance optimization investigation
/sc:troubleshoot "slow database queries affecting user experience"
# → performance-engineer + root-cause-analyst + backend-architect
```

```bash
# Security assessment
/sc:analyze "authentication system for GDPR compliance vulnerabilities"
# → security-engineer + quality-engineer + requirements-analyst
```

--------------------------------

### SuperClaude CLI: Tool Integration Examples

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

Demonstrates integrating external tools like Context7 and Serena for specific tasks. Includes using Context7 for official patterns, Serena for project memory, and the `--uc` flag for efficient token usage with large projects.

```bash
# Use Context7 for official patterns
/sc:implement "React hooks implementation" --c7


# Use Serena for project memory
/sc:analyze . --serena --focus architecture


# Efficient token usage
/sc:analyze large-project/ --uc
```

--------------------------------

### Verify npm MCP Server Installation

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Lists globally installed npm packages and filters for 'mcp' to confirm that the necessary MCP servers are installed. This is part of the essential verification pattern.

```bash
npm list -g | grep mcp
```

--------------------------------

### Install SuperClaude Framework Components (Bash)

Source: https://superclaude.netlify.app/docs/Developer-Guide/contributing-code

Commands to clone the SuperClaude framework repository, navigate into the directory, and install core components using the setup script. Ensure you replace 'YOUR_USERNAME' with your GitHub username and '/path/to/SuperClaude_Framework' with the actual local path.

```bash
# Fork SuperClaude_Framework on GitHub first
git clone https://github.com/YOUR_USERNAME/SuperClaude_Framework.git
cd SuperClaude_Framework

# Test installation system
PYTHONPATH=/path/to/SuperClaude_Framework python3 -m setup --help

# Install to development location
PYTHONPATH=/path/to/SuperClaude_Framework python3 -m setup install --components core
```

--------------------------------

### Execute Package with npx (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Demonstrates how to execute a package binary directly using npx, which downloads and runs the package without a global installation. This is useful for testing or running specific package commands.

```bash
npx @context7/mcp-server --version
```

--------------------------------

### Install SuperClaude using pipx (Python)

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Installs SuperClaude using pipx, a tool for managing Python applications in isolated environments. This method is recommended for a clean and conflict-free installation on Linux and macOS.

```python
# Install pipx if not present
python3 -m pip install --user pipx
python3 -m pipx ensurepath

# Install SuperClaude
pipx install SuperClaude

# Run the installer
SuperClaude install
```

--------------------------------

### Mode Combination Command Example

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Shows how to combine different SuperClaude modes using command-line arguments, specifically demonstrating a workflow from 'brainstorm' to 'task-manage' for microservices architecture discovery and planning.

```bash
# Discovery → Planning → Implementation
/sc:brainstorm "microservices architecture" --task-manage
# → Brainstorming: requirement discovery
# → Task Management: multi-phase coordination
```

--------------------------------

### Troubleshoot SuperClaude Package Installation

Source: https://superclaude.netlify.app/docs/Reference/troubleshooting

Provides commands for uninstalling and reinstalling SuperClaude, addressing issues where package installation might fail. Includes steps for both pipx and pip users.

```bash
# For pipx users
pipx uninstall SuperClaude
pipx install SuperClaude

# For pip users
pip uninstall SuperClaude
pip install --upgrade pip
pip install SuperClaude
```

--------------------------------

### Check Node.js and MCP Server Installation (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Verifies that Node.js is installed and meets the version requirement (16.0.0+) and checks if the '@context7/mcp-server' package is globally installed. This is part of diagnosing connection failures.

```bash
# Check Node.js installation
node --version  # Should be 16.0.0 or higher
npm list -g @context7/mcp-server
```

--------------------------------

### Test Individual MCP Server Functionality

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

This script checks for the presence and installation of various MCP server components, including Context7, Sequential, Magic, and Playwright. It confirms if each required component is correctly installed and available for use.

```bash
# Test each MCP server individually
echo "=== MCP Server Functionality Test ==="

# Context7 test
if npm list -g @context7/mcp-server > /dev/null 2>&1; then
    echo "✅ Context7 installed"
else
    echo "❌ Context7 missing"
fi

# Sequential test
if npm list -g @sequential/mcp-server > /dev/null 2>&1; then
    echo "✅ Sequential installed"
else
    echo "❌ Sequential missing"
fi

# Magic test
if npm list -g @magic/ui-generator > /dev/null 2>&1; then
    echo "✅ Magic installed"
else
    echo "❌ Magic missing"
fi

# Playwright test
if npx playwright --version > /dev/null 2>&1; then
    echo "✅ Playwright installed"
else
    echo "❌ Playwright missing"
fi
```

--------------------------------

### Quick System Check Script (Bash)

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

A bash script to quickly verify the presence and versions of essential requirements like Python, Claude Code, Node.js, and Git. It provides immediate feedback on whether each component is installed and accessible.

```bash
# Run this to check all requirements at once
python3 --version && echo "✅ Python OK" || echo "❌ Python missing"
claude --version && echo "✅ Claude Code OK" || echo "❌ Claude Code missing"
node --version 2>/dev/null && echo "✅ Node.js OK (optional)" || echo "⚠️ Node.js missing (optional)"
git --version 2>/dev/null && echo "✅ Git OK (optional)" || echo "⚠️ Git missing (optional)"
```

--------------------------------

### Check Sequential Server Installation

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Verifies if the Sequential MCP server package is globally installed and lists its version.

```bash
npm list -g @sequential/mcp-server
```

--------------------------------

### Verify npm Package Installation (Node.js)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

A simple Node.js script to verify if a global package like '@context7/mcp-server' is installed and executable. It attempts to log a message, confirming the environment is set up.

```javascript
console.log('Context7 installation test')
```

--------------------------------

### SuperClaude CLI: Week 1 Learning Workflow (Basic Commands)

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

A guided workflow for the first week of learning SuperClaude, covering basic analysis, implementation, and testing commands with a focus on quality. Also includes troubleshooting and analyzing specific problem areas.

```bash
# Day 1-2: Basic commands
/sc:analyze . --focus quality
/sc:implement "simple feature"
/sc:test --focus quality

# Day 3-4: Troubleshooting
/sc:troubleshoot "specific problem"
/sc:analyze problem-area/ --focus relevant-domain

# Day 5-7: Integration
/sc:brainstorm "project idea"
/sc:implement "core feature"
/sc:test --focus quality
```

--------------------------------

### Reset SuperClaude Installation

Source: https://superclaude.netlify.app/docs/Reference/troubleshooting

Commands to perform a clean reset of the SuperClaude installation, including backing up existing data, uninstalling, and performing a fresh install.

```bash
SuperClaude backup --create          # Backup first
SuperClaude uninstall
SuperClaude install --fresh
```

--------------------------------

### New Project Initialization Lifecycle Pattern

Source: https://superclaude.netlify.app/docs/User-Guide/session-management

Demonstrates a typical workflow for starting a new project with SuperClaude, involving initial brainstorming, saving scope, planning workflows, and persisting architectural decisions.

```bash
# 1. Start fresh project
/sc:brainstorm "e-commerce platform requirements"

# 2. Save initial decisions to persistent memory
/sc:save "project scope and requirements defined"

# 3. Begin implementation planning
/sc:workflow "user authentication system"

# 4. Save architectural decisions permanently
/sc:save "auth architecture: JWT + refresh tokens + rate limiting"
```

--------------------------------

### Analyze SuperClaude Installation Files

Source: https://superclaude.netlify.app/docs/Reference/troubleshooting

Lists files in the SuperClaude installation directory and searches for lines containing '@' in CLAUDE.md, useful for verifying component integrity and imports.

```bash
ls -la ~/.claude/                    # Check installed files
grep -r "@" ~/.claude/CLAUDE.md      # Verify imports
```

--------------------------------

### SuperClaude Terminal Installation Commands (Bash)

Source: https://superclaude.netlify.app/docs/User-Guide/commands

Commands executed in the terminal for managing the SuperClaude framework installation. This includes installing, updating, and uninstalling the framework components.

```bash
# Terminal Commands (Actual CLI software):
SuperClaude install
SuperClaude update
SuperClaude uninstall
```

--------------------------------

### MCP Server Configuration in .claude.json

Source: https://superclaude.netlify.app/docs/User-Guide/mcp-servers

Example JSON configuration file for setting up and managing MCP servers within SuperClaude, specifying commands, arguments, and environment variables for each server.

```json
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    },
    "sequential-thinking": {
      "command": "npx", 
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "magic": {
      "command": "npx",
      "args": ["@21st-dev/magic"],
      "env": {"TWENTYFIRST_API_KEY": "${TWENTYFIRST_API_KEY}"}
    },
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    },
    "morphllm-fast-apply": {
      "command": "npx",
      "args": ["@morph-llm/morph-fast-apply"],
      "env": {"MORPH_API_KEY": "${MORPH_API_KEY}"}
    },
    "serena": {
      "command": "uv",
      "args": ["run", "serena", "start-mcp-server", "--context", "ide-assistant"],
      "cwd": "$HOME/.claude/serena"
    }
  }
}
```

--------------------------------

### List Globally Installed npm Packages (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Lists all globally installed npm packages with a depth of 0, showing only top-level packages. Useful for verifying installations and checking for conflicts.

```bash
npm list -g --depth=0
```

--------------------------------

### Install Playwright Browsers

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Installs Playwright and its required browser binaries. This is crucial for enabling Playwright's browser automation capabilities. It can install all browsers or specific ones like Chromium.

```bash
npx playwright install
npx playwright install-deps
```

```bash
npx playwright install chromium
npx playwright install firefox
npx playwright install webkit
```

--------------------------------

### Install Build Dependencies on macOS (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Installs the Xcode command-line tools on macOS, which provide necessary compilers and build utilities. This is often required for packages with native extensions.

```bash
xcode-select --install
```

--------------------------------

### Install SuperClaude Framework (Bash)

Source: https://context7.com/context7/superclaude_netlify_app/llms.txt

Installs the SuperClaude framework using pipx, pip, or npm. It also includes commands to verify the installation and list installed components. Recommended installation is with pipx for an isolated environment.

```bash
# Recommended: Install with pipx for isolated environment
pipx install SuperClaude && SuperClaude install

# Alternative: Traditional pip installation
pip install SuperClaude && SuperClaude install

# Alternative: NPM installation for Node.js developers
npm install -g @bifrost_inc/superclaude && superclaude install

# Verify installation
python3 -m SuperClaude --version
# Expected output: SuperClaude 4.0.8

# List installed components
SuperClaude install --list-components
# Expected output: Shows installed commands, agents, modes, and MCP servers
```

--------------------------------

### Troubleshoot 'Command Not Found' Error

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Steps to resolve the 'Command Not Found' error after installing SuperClaude. This includes checking the installation, running via Python module, and adding the user binary directory to the PATH.

```bash
# Check if package is installed
python3 -m pip show SuperClaude

# Run using Python module
python3 -m SuperClaude install

# Add to PATH (if using --user)
export PATH="$HOME/.local/bin:$PATH"
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc  # Linux
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc   # macOS
```

--------------------------------

### SuperClaude CLI Workflow Example: New Project Development

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Illustrates a complete workflow for new project development using the SuperClaude CLI, showcasing automatic mode activation for discovery, planning, and implementation phases.

```bash
# Phase 1: Discovery (Brainstorming Mode auto-activates)
"I want to build a productivity app"
→ 🤔 Socratic questions about users, features, platform choice
→ 📝 Structured requirements brief

# Phase 2: Planning (Task Management Mode auto-activates)  
/sc:implement "core productivity features"
→ 📋 Multi-phase breakdown with dependencies
→ 🎯 Phase coordination with quality gates

# Phase 3: Implementation (Orchestration Mode coordinates tools)
/sc:develop frontend + backend
→ 🎯 Magic (UI) + Context7 (patterns) + Sequential (architecture)
→ ⚡ Parallel execution optimization
```

--------------------------------

### Update and Backup SuperClaude

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Commands for updating SuperClaude to the latest version using pip and the SuperClaude update command. Also includes commands for creating and restoring backups.

```bash
# Update to latest
pip install --upgrade SuperClaude
SuperClaude update

# Create backup
SuperClaude backup --create

# Restore backup
SuperClaude backup --restore [file]
```

--------------------------------

### Install and Use Node Version Manager (nvm) (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

This code installs Node Version Manager (nvm) and then uses it to install and set the latest Node.js version as the default. nvm is a flexible way to manage multiple Node.js versions.

```bash
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
source ~/.bashrc
nvm install node
nvm use node
```

--------------------------------

### Install SuperClaude using npm (Node.js)

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Installs SuperClaude globally using npm, the Node Package Manager. This method is ideal for Node.js developers or those who prefer managing packages through the npm ecosystem.

```javascript
# Global installation
npm install -g @bifrost_inc/superclaude

# Run the installer
superclaude install
```

--------------------------------

### Count Installed SuperClaude Components

Source: https://superclaude.netlify.app/docs/Developer-Guide/testing-debugging

Counts the number of installed context files for agents, commands, and modes within the SuperClaude framework. This helps verify that all expected components have been installed correctly.

```bash
# Should have 14 agents
ls ~/.claude/agents/*.md | wc -l

# Should have 21 commands  
ls ~/.claude/commands/*.md | wc -l

# Should have 5 modes
ls ~/.claude/modes/*.md | wc -l
```

--------------------------------

### Resolve PEP 668 Error with pipx

Source: https://superclaude.netlify.app/docs/Getting-Started/installation

Instructions for resolving the PEP 668 error, which occurs in systems with externally managed Python environments. The recommended solution is to use pipx for installation.

```bash
# Option 1: Use pipx (Recommended)
pipx install SuperClaude

# Option 2: User installation
pip install --user SuperClaude

# Option 3: Virtual environment
python3 -m venv superclaude-env
source superclaude-env/bin/activate  # Linux/macOS
# or
superclaude-env\Scripts\activate  # Windows
pip install SuperClaude

# Option 4: Force (use with caution)
pip install --break-system-packages SuperClaude
```

--------------------------------

### Check Magic UI Generator Installation

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Verifies if the Magic UI Generator package is globally installed and checks for Magic-related configurations in the CLAUDE.md file.

```bash
npm list -g @magic/ui-generator
cat ~/.claude/CLAUDE.md | grep -i magic
```

--------------------------------

### AI Agent for Simple Feature Implementation (Authentication)

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

Provides an example of implementing a complete authentication system using '/sc:implement', specifying requirements like JWT tokens and password hashing. The expected output is a production-ready system with secure practices and proper error handling.

```bash
# Complete authentication system
/sc:implement "user login with JWT tokens and password hashing"

# Expected Implementation:
# - Secure password hashing with bcrypt
# - JWT token generation and validation
# - Login/logout endpoints with proper error handling
# - Frontend login form with validation

# Activates: security-engineer + backend-architect + Context7
# Output: Production-ready authentication system


# Variations for different auth needs:
/sc:implement "OAuth integration with Google and GitHub"
/sc:implement "password reset flow with email verification"
/sc:implement "two-factor authentication with TOTP"
```

--------------------------------

### Development → Quality Pattern with AI Agents

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

This workflow emphasizes building a feature, thoroughly testing it, and then refining based on analysis. It starts with '/sc:implement', moves to '/sc:test' for quality assurance, and uses '/sc:analyze' followed by '/sc:implement' for improvements.

```bash
# Step 1: Build the feature
/sc:implement "user registration with email verification"
# Expected: Registration system with email integration

# Step 2: Test thoroughly
/sc:test --focus quality
# Expected: Comprehensive test coverage and validation

# Step 3: Review and improve
/sc:analyze . --focus quality && /sc:implement "quality improvements"
# Expected: Quality assessment and targeted improvements
```

--------------------------------

### Token Efficiency Mode Example

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Illustrates the compressed communication style of Token Efficiency Mode, contrasting a standard verbose explanation with a symbolic and abbreviated version for a security alert.

```text
"🛡️ Security Alert:
 auth.js:45 → user val() → critical vuln
 📊 Impact: ❌ token bypass possible
 ⚡ Action: fix validation + audit ∵ high sev
 🔧 Est: 2h impl + 1h test"
```

--------------------------------

### Update and Reinstall Context7 MCP Server

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Commands to uninstall the current Context7 MCP server and install the latest version to resolve issues with outdated information.

```bash
npm uninstall -g @context7/mcp-server
npm install -g @context7/mcp-server@latest
```

--------------------------------

### Orchestration Mode Example

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Demonstrates the multi-tool coordination strategy used in Orchestration Mode, outlining distinct phases with specific tools and highlighting parallel execution capabilities for optimized task handling.

```text
"🎯 Multi-Tool Coordination Strategy:
 🔍 Phase 1: Serena (semantic analysis) + Sequential (architecture review)
 ⚡ Phase 2: Morphllm (pattern edits) + Magic (UI components) 
 🧪 Phase 3: Playwright (testing) + Context7 (documentation patterns)
 🔄 Parallel execution: 3 tools working simultaneously
"
```

--------------------------------

### AI Agent for Project Analysis and Quality Assessment

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

This example demonstrates a comprehensive project understanding workflow using '/sc:load' and '/sc:analyze' with a focus on quality. It activates multiple agents for analysis, documentation, and recommendations, producing a detailed project report.

```bash
# Complete project understanding workflow
/sc:load . && /sc:analyze --focus quality

# Expected Results:
# - Project structure analysis and documentation
# - Code quality assessment across all files
# - Architecture overview with component relationships
# - Security audit and performance recommendations

# Activates: Serena (project loading) + analyzer + security-engineer + performance-engineer
# Output: Comprehensive project report with actionable insights


# Variations for different focuses:
/sc:analyze src/ --focus quality          # Code quality only
/sc:analyze . --scope file               # Quick file analysis
/sc:analyze backend/ --focus security    # Backend security review
```

--------------------------------

### Bug Investigation Workflow Example

Source: https://superclaude.netlify.app/docs/User-Guide/commands

Outlines a process for investigating and fixing bugs, involving troubleshooting, in-depth analysis, and applying fixes.

```bash
# Diagnose the described issue
/sc:troubleshoot "issue description"

# Perform a deep analysis focused on the problem area
/sc:analyze --focus problem-area

# Apply targeted fixes in a safe mode
/sc:improve --fix --safe-mode
```

--------------------------------

### Check for Build Tools (GCC, Make) (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Verifies if essential build tools like GCC and Make are installed and available in the system's PATH. These tools are often required for compiling native modules during npm package installations.

```bash
which gcc make
```

--------------------------------

### Install Playwright Dependencies on Linux

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Installs necessary system dependencies for Playwright browser automation on Linux systems. This resolves potential issues related to missing libraries required for browser execution.

```bash
sudo apt-get install libnss3 libatk-bridge2.0-0 libdrm2 libgtk-3-0
```

--------------------------------

### Verify SuperClaude Installation Status

Source: https://superclaude.netlify.app/docs/Developer-Guide/testing-debugging

Checks if the SuperClaude installation system and Claude Code CLI are accessible and reports their versions. It also verifies the presence and basic content of core context files and directory structure.

```bash
# Verify SuperClaude installation system is available
python3 -m SuperClaude --version
# Expected: SuperClaude Framework installation help

# Verify Claude Code CLI integration
claude --version
# Expected: Claude Code version info

# Check if context files were installed
ls ~/.claude/
# Expected: CLAUDE.md, FLAGS.md, RULES.md, agents/, commands/, modes/

# Verify main context file
head ~/.claude/CLAUDE.md
# Expected: Should show import statements
```

--------------------------------

### Install Build Dependencies on Linux (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Installs the `build-essential` package (which includes GCC, Make, etc.) and `python3-dev` on Debian-based Linux systems. These are common build dependencies for Node.js native modules.

```bash
sudo apt install build-essential python3-dev
```

--------------------------------

### Check Node.js and npm Versions (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

This snippet demonstrates how to check the installed versions of Node.js and npm using bash commands. This is often the first step in troubleshooting compatibility issues with MCP servers.

```bash
node --version
npm --version
```

--------------------------------

### Install Missing SuperClaude Components

Source: https://superclaude.netlify.app/docs/Reference/common-issues

Installs specified SuperClaude components, including core, commands, agents, and modes, with a force option to ensure installation.

```bash
python3 -m SuperClaude install --components core commands agents modes --force
```

--------------------------------

### Install npm Package with Alternative Registry (Bash)

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Installs a global npm package while explicitly specifying the official npm registry. This can help resolve issues if the default registry is experiencing problems or if a private registry is interfering.

```bash
npm install -g @context7/mcp-server --registry https://registry.npmjs.org/
```

--------------------------------

### Resolve Permission Denied or PEP 668 Errors

Source: https://superclaude.netlify.app/docs/Reference/troubleshooting

Offers solutions for permission errors during SuperClaude installation, including using pipx, pip with --user, fixing directory permissions, or forcing installation (with caution).

```bash
# Option 1: Use pipx (recommended)
pipx install SuperClaude

# Option 2: Use pip with --user flag
pip install --user SuperClaude

# Option 3: Fix permissions
sudo chown -R $USER ~/.claude

# Option 4: Force installation (use with caution)
pip install --break-system-packages SuperClaude
```

--------------------------------

### SuperClaude CLI Mode Combination Example: High-Complexity Scenarios

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Demonstrates combining multiple modes for high-complexity scenarios, such as large refactoring tasks, utilizing introspection, token efficiency, and orchestration.

```bash
# Large refactoring with multiple constraints
/sc:modernize legacy-system/ --introspect --uc --orchestrate
→ 🔍 Transparent reasoning (Introspection)
→ ⚡ Compressed communication (Token Efficiency)  
→ 🎯 Optimal tool coordination (Orchestration)
→ 📋 Systematic phases (Task Management auto-activates)
```

--------------------------------

### SuperClaude CLI Workflow Example: Debugging Complex Issues

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Provides an example of debugging complex issues using the SuperClaude CLI, highlighting the automatic activation of introspection for problem analysis and task management for systematic resolution.

```bash
# Problem analysis (Introspection Mode auto-activates)
"Users getting intermittent auth failures"
→ 🤔 Transparent reasoning about potential causes
→ 🎯 Hypothesis formation and evidence gathering
→ 💡 Pattern recognition across similar issues

# Systematic resolution (Task Management coordinates)
/sc:fix auth-system --comprehensive
→ 📋 Phase 1: Root cause analysis
→ 📋 Phase 2: Solution implementation  
→ 📋 Phase 3: Testing and validation
```

--------------------------------

### Verify and Update Magic UI Generator

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Ensures the Magic UI Generator is installed and updates it to the latest version to resolve generation issues.

```bash
npm list -g @magic/ui-generator
npm install -g @magic/ui-generator@latest
```

--------------------------------

### Troubleshoot MCP Server Issues

Source: https://superclaude.netlify.app/docs/Developer-Guide/testing-debugging

Provides verification steps for when MCP features are unavailable. It includes checking the Node.js installation and verifying the syntax of the `.claude.json` configuration file.

```bash
# Check Node.js installation
which node

# Verify .claude.json syntax
python3 -c "import json; json.load(open('$HOME/.claude.json'))" && echo "✅ Valid JSON" || echo "❌ Invalid JSON"

# Solution:
# Install Node.js if missing

```

--------------------------------

### Full-Stack Development and Integration Testing with SuperClaude

Source: https://superclaude.netlify.app/docs/Reference/README

Examples for utilizing SuperClaude flags in full-stack application workflows and for implementing end-to-end integration testing strategies.

```bash
# Complete application workflow
--task-manage --all-mcp "build full-stack e-commerce platform"

# Integration testing
--play --seq "implement end-to-end testing strategy"
```

--------------------------------

### Test MCP Server Availability

Source: https://superclaude.netlify.app/docs/Developer-Guide/testing-debugging

Verifies that Node.js and npx are installed and available, which are prerequisites for running MCP servers. It then attempts to test the availability of the Context7 MCP server.

```bash
# Check if Node.js is available (required for MCP)
node --version
# Expected: v16.0.0 or higher

# Check if npx is available
npx --version
# Expected: Version number

# Test Context7 MCP (if configured)
npx -y @upstash/context7-mcp@latest --help 2>/dev/null && echo "✅ Context7 available" || echo "❌ Context7 not available"
```

--------------------------------

### Discovery → Implementation Pattern with AI Agents

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

This pattern shows a phased approach starting with requirement discovery using '/sc:brainstorm', followed by technical analysis with '/sc:analyze', and concluding with implementation using '/sc:implement'. It's designed for building complex features like web dashboards.

```bash
# Step 1: Explore and understand requirements
/sc:brainstorm "web dashboard for project management"
# Expected: Requirements discovery, feature prioritization, technical scope

# Step 2: Analyze technical approach
/sc:analyze "dashboard architecture patterns" --focus architecture --c7
# Expected: Architecture patterns, technology recommendations, implementation strategy

# Step 3: Implement core functionality
/sc:implement "React dashboard with task management and team collaboration"
# Expected: Complete dashboard implementation with modern React patterns
```

--------------------------------

### Reinstall Serena MCP Server

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Uninstalls and then reinstalls the `@serena/mcp-server` package globally. This is a common troubleshooting step for issues related to the Serena server, ensuring a clean installation.

```bash
npm uninstall -g @serena/mcp-server
npm install -g @serena/mcp-server@latest
```

--------------------------------

### Install SuperClaude on Windows

Source: https://superclaude.netlify.app/docs/Reference/common-issues

Sets the CLAUDE_CONFIG_DIR environment variable and installs SuperClaude with a specified installation directory for Windows systems.

```cmd
set CLAUDE_CONFIG_DIR=%USERPROFILE%\.claude
python -m SuperClaude install --install-dir "%CLAUDE_CONFIG_DIR%"
```

--------------------------------

### SuperClaude CLI: Multi-Step Project Integration Workflow

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

Demonstrates a workflow for managing multi-step projects over weeks 3-4, including brainstorming larger projects, implementing phases, and testing with focuses on quality and integration.

```bash
# Multi-step projects
/sc:brainstorm "larger project"
/sc:implement "phase 1"
/sc:test --focus quality
/sc:implement "phase 2"
/sc:test --focus integration
```

--------------------------------

### Install SuperClaude on Linux

Source: https://superclaude.netlify.app/docs/Reference/common-issues

Installs Python 3, pip3, and Node.js using apt package manager, then installs SuperClaude using pip3.

```bash
sudo apt install python3 python3-pip nodejs
pip3 install SuperClaude
```

--------------------------------

### React/Next.js Framework Integration with SuperClaude

Source: https://superclaude.netlify.app/docs/Reference/README

Examples demonstrating how to use SuperClaude flags for initializing React/Next.js projects with specific patterns and for component development workflows.

```bash
# Initialize with React patterns
--c7 --magic "implement Next.js authentication with TypeScript"

# Component development workflow  
--magic --think "create responsive dashboard component"
```

--------------------------------

### SuperClaude Command Examples

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Demonstrates how to activate SuperClaude's behavioral modes using slash commands and flags. These commands automatically trigger specific modes based on task complexity or can be used for manual control.

```bash
# Automatic activation examples
/sc:brainstorm "mobile app"        # → Socratic discovery questions
/sc:implement "auth system"        # → Multi-phase coordination  
"--uc analyze large-codebase/"     # → Compressed symbol output
```

--------------------------------

### Verify SuperClaude Installation

Source: https://superclaude.netlify.app/docs/Reference/common-issues

Check if SuperClaude is installed correctly by running the version command. If not, provides upgrade commands for pipx and pip users, followed by a reinstallation command.

```bash
python3 -m SuperClaude --version    # Should show 4.0.8

# If not working:
# For pipx users
pipx upgrade SuperClaude

# For pip users
pip install --upgrade SuperClaude

# Then reinstall
python3 -m SuperClaude install
```

--------------------------------

### Troubleshoot SuperClaude MCP Server Connections

Source: https://superclaude.netlify.app/docs/Reference/troubleshooting

Checks for the existence of the MCP server configuration file and verifies Node.js version. Also includes a command to force install MCP components.

```bash
ls ~/.claude/.claude.json            # Check config exists
node --version                       # Verify Node.js 16+
SuperClaude install --components mcp --force
```

--------------------------------

### Update Morphllm MCP Server

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Updates the globally installed `@morphllm/mcp-server` package to its latest version. This ensures the pattern editor server has the most recent improvements and bug fixes.

```bash
npm update -g @morphllm/mcp-server
```

--------------------------------

### Activate Context7 Server for Documentation

Source: https://superclaude.netlify.app/docs/User-Guide/mcp-servers

Demonstrates automatic and manual activation of the context7 MCP server, used for accessing official library documentation and patterns. Requires Node.js 16+ and no API key.

```bash
# Automatic activation
/sc:implement "React authentication system"
# → Provides official React patterns

# Manual activation  
/sc:analyze auth-system/ --c7
```

--------------------------------

### SuperClaude CLI Manual Mode Control Examples

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Demonstrates how to manually force specific behaviors or modes in the SuperClaude CLI, such as brainstorming, introspection, task management, orchestration, or token compression (uc).

```bash
# Force collaborative discovery on implementing user login
/sc:implement "user login" --brainstorm

# Add reasoning transparency to debugging authentication issues
/sc:fix auth-issue --introspect

# Enable task management for updating styles
/sc:update styles.css --task-manage
```

--------------------------------

### Sequential Specialist Chain Pattern for AI Agents

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

Illustrates a workflow where AI agents are chained sequentially to perform distinct phases of a development process, such as design, security review, implementation, and DevOps setup. This ensures a structured and comprehensive approach to complex tasks like microservices architecture.

```bash
# Design phase
@agent-system-architect "design microservices architecture for e-commerce"

# Security review
@agent-security "review architecture for security boundaries"

# Implementation guidance
@agent-backend-architect "implement service communication patterns"

# DevOps setup
@agent-devops-architect "configure CI/CD for microservices"
```

--------------------------------

### Reinstall Sequential MCP Server

Source: https://superclaude.netlify.app/docs/Reference/mcp-server-guide

Uninstalls and then reinstalls the latest version of the Sequential MCP server to resolve potential corruption or outdated issues.

```bash
npm uninstall -g @sequential/mcp-server
npm install -g @sequential/mcp-server@latest
```

--------------------------------

### Activate Serena Server for Semantic Code Understanding

Source: https://superclaude.netlify.app/docs/User-Guide/mcp-servers

Illustrates activating the serena MCP server for semantic code understanding and project memory. Requires Python 3.9+, uv package manager, and no API key.

```bash
# Automatic activation  
/sc:load existing-project/
# → Builds project understanding and memory

# Manual activation
/sc:refactor "extract UserService" --serena
```

--------------------------------

### Bash: Check SuperClaude Installation Version

Source: https://superclaude.netlify.app/docs/Reference/diagnostic-reference

Verifies the SuperClaude installation by attempting to display its version using the python3 module. This command is useful for confirming that SuperClaude is installed and can be executed.

```bash
# Check if SuperClaude is installed
python3 -m SuperClaude --version
```

--------------------------------

### Task Management Mode Example Plan (Pseudo-code)

Source: https://superclaude.netlify.app/docs/User-Guide/modes

Illustrates the hierarchical planning structure of SuperClaude's Task Management Mode, emphasizing phased implementation, session persistence, and quality gates for complex operations.

```pseudo
Standard Approach: "I'll implement user authentication..." → Direct implementation
Task Management Approach:
"📋 Multi-Phase Implementation Plan:
 🎯 Phase 1: Security Requirements Analysis (Session 1)
 🎯 Phase 2: API Design & Documentation (Session 2)  
 🎯 Phase 3: Implementation & Testing (Session 3-4)
 🎯 Phase 4: Integration & Validation (Session 5)
 💾 Session persistence: Resume context automatically
 ✓ Quality gates: Validation before each phase transition"
```

--------------------------------

### SuperClaude CLI: Workflow and Problem-Solving Patterns

Source: https://superclaude.netlify.app/docs/Reference/basic-examples

Illustrates common workflow patterns for SuperClaude, including sequential execution for brainstorming, analysis, implementation, and testing. Also shows patterns for troubleshooting and quality assurance.

```bash
# Workflow patterns
/sc:brainstorm → /sc:analyze → /sc:implement → /sc:test

# Problem-solving patterns
/sc:troubleshoot → /sc:analyze → /sc:implement

# Quality patterns
/sc:analyze → /sc:implement → /sc:test → /sc:analyze
```

--------------------------------

### Install SuperClaude on macOS

Source: https://superclaude.netlify.app/docs/Reference/common-issues

Installs Python 3 and Node.js using Homebrew, then installs SuperClaude using pip3.

```bash
brew install python3 node
pip3 install SuperClaude
```
Tokens:
Raw