SuperClaude Framework

https://github.com/superclaude-org/superclaude_plugin
Admin
SuperClaude is a meta-programming configuration framework that transforms Claude Code into a...
Tokens:94,969
Snippets:1,288
Trust Score:7.5
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Installation and Setup Commands

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/documentation-specialist.md

Shell commands for cloning, installing, and running the application.

```bash
git clone https://github.com/user/my-fastapi-app.git
cd my-fastapi-app
```

```bash
poetry install
```

```bash
cp .env.example .env
# Edit .env with your configuration
```

```bash
alembic upgrade head
```

```bash
uvicorn main:app --reload
```

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

### Generate User Guide Documentation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-document.md

Create user-focused documentation with practical examples and implementation patterns for a specific module. Use the 'guide' type and 'brief' style for concise guidance.

```bash
/sc:sc:document payment-module --type guide --style brief
# Creates user-focused documentation with practical examples
# Focuses on implementation patterns and common use cases
```

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

### Plugin Installation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/benchmark/BIAS_ANALYSIS.md

Demonstrates the simple installation process for the SuperClaude Plugin, highlighting its quick setup time.

```bash
# Plugin
/plugin install sc@superclaude
# Time: ~30 seconds
```

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

### MCP Gateway Setup Steps

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/benchmark/BIAS_ANALYSIS.md

Outlines the multi-step setup process for the MCP Gateway, including installation, configuration, and authentication, indicating a longer setup time compared to the Plugin.

```bash
# MCP Gateway
1. Install airis-workspace CLI
2. Configure MCP server
3. Set environment variables
4. Test connection
5. Authenticate
# Time: ~5-10 minutes
```

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

### Alternative Example Command

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

Use this command to get recommendations for a new project, including a primary build command and alternative approaches with pros, cons, and user preferences.

```bash
/sc:sc:recommend --alternatives "new blog site"
```

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

### Session 1: Initialize Authentication Task

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/modes/MODE_Task_Management.md

Example of starting a new task, initializing memory with plan, phase, and task details, and updating status upon completion.

```shell
list_memories() → Empty
write_memory("plan_auth", "Implement JWT authentication system")
write_memory("phase_1", "Analysis - security requirements review")
write_memory("task_1.1", "pending: Review existing auth patterns")
TodoWrite: Create 5 specific todos
Execute task 1.1 → write_memory("task_1.1", "completed: Found 3 patterns")
```

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

### Recommendations Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-sc.md

Example usage of the recommend command.

```text
/sc:sc:recommend
```

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

### Index Repository Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-sc.md

Example usage of the index-repo command.

```text
/sc:sc:index-repo
```

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

### Execute multi-language command examples

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

Example inputs for the recommendation engine across Turkish, English, and mixed-language queries.

```bash
# Turkish examples
/sc:sc:recommend "makine öğrenmesi algoritması başlat"
/sc:sc:recommend "sitem yavaş açılıyor, ne yapayım?"
/sc:sc:recommend "yeni bir özellik eklemeliyim"
/sc:sc:recommend "hata alıyorum, çözüm bul"

# English examples
/sc:sc:recommend "I want to build ML algorithm"
/sc:sc:recommend "my website is slow, help me optimize"
/sc:sc:recommend "I need to add a new feature"
/sc:sc:recommend "getting errors, need debugging"

# Mixed language
/sc:sc:recommend "makine learning projesi yapmak istiyorum"
```

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

### Context-Aware Recommendation Examples

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

Examples of generating project-specific recommendations based on user input and detected context.

```bash
/sc:sc:recommend "I need to add a new feature"

🎯 Project Analysis: React project - Feature development
📁 Project Context: React application detected (15+ components)
🎭 Persona: --persona-frontend + --persona-qa

✅ Context-Aware Recommendations:
1. /sc:sc:build --feature --magic --react --persona-frontend
   "New component compatible with existing design system"

2. /sc:sc:test --coverage --e2e --pup --persona-qa
   "Create tests for new feature"

3. /sc:sc:analyze --code --c7 --persona-frontend
   "React best practices check"

💡 Project-Specific Flags:
--storybook-integration (if Storybook exists)
--component-library (if it's a component library)
--design-system (integration with existing design system)
```

```bash
/sc:sc:recommend "I need to do a security audit"

🎯 Project Analysis: Node.js API - Security audit
📁 Project Context: Express API detected (JWT auth exists)
🎭 Persona: --persona-security + --persona-backend

✅ Context-Aware Recommendations:
1. /sc:sc:scan --security --owasp --deps --strict --persona-security
   "OWASP Top 10 and dependency security scan"

2. /sc:sc:analyze --security --seq --persona-security
   "JWT and authentication pattern analysis"

3. /sc:sc:improve --security --harden --persona-backend
   "Security hardening and production configs"

💡 Project-Specific Flags:
--jwt-validation (JWT token validation)
--rate-limiting (API rate limiting)
--audit-logging (audit logging setup)
```

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

### Framework-Specific Implementation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-implement.md

Example command for generating a Vue component using Context7 MCP for framework-specific patterns.

```text
/sc:sc:implement dashboard widget --framework vue
# Context7 MCP provides Vue-specific patterns and documentation
# Framework-appropriate implementation with official best practices
```

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

### Measure Setup Time

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/benchmark/BIAS_ANALYSIS.md

This bash script describes a test to measure the setup time for both the SuperClaude Plugin and MCP Gateway. It involves a fresh installation and timing until the first successful command execution.

```bash
# Fresh install
# Time to first successful command
# Report: Plugin vs MCP
```

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

### Agile Feature Exploration Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-brainstorm.md

Enables parallel exploration of real-time collaboration features using an agile strategy. This setup involves frontend, backend, and security personas, with Context7 and Magic MCP for framework and UI pattern analysis.

```bash
/sc:sc:brainstorm "real-time collaboration features" --strategy agile --parallel
# Parallel exploration paths with frontend, backend, and security personas
# Context7 and Magic MCP for framework and UI pattern analysis
```

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

### Install uv

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/verify-mcp.md

Install the uv package manager if uvx is missing.

```bash
# Install uv (includes uvx)
pip install uv
# or
brew install uv
```

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

### Install Prerequisites

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README-zh.md

Install the uv package manager required for the MCP server.

```bash
# 安装 uvx（MCP 服务器所需）
pip install uv
# 或
brew install uv
```

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

### API Service Implementation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-implement.md

Example command for creating a secure API service with integrated testing.

```text
/sc:sc:implement user authentication API --type api --safe --with-tests
# Backend persona handles server-side logic and data processing
# Security persona ensures authentication best practices
```

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

### Quick Setup for AIRIS MCP Gateway

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Clone the AIRIS MCP Gateway repository, navigate into its directory, and run the 'just up' command to start the gateway. Then, add the MCP server to your Claude client using the provided command.

```bash
git clone https://github.com/agiletec-inc/airis-mcp-gateway.git
cd airis-mcp-gateway && just up
claude mcp add --transport http airis-mcp-gateway http://api.gateway.localhost:9400/api/v1/mcp
```

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

### Full-Stack Feature Implementation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-implement.md

Example command for a complex feature requiring multi-persona coordination and sequential planning.

```text
/sc:sc:implement payment processing system --type feature --with-tests
# Multi-persona coordination: architect, frontend, backend, security
# Sequential MCP breaks down complex implementation steps
```

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

### Manage Plugin Installation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/verify-mcp.md

Verify the plugin installation status or perform an update.

```bash
# Check plugin is installed
/plugin list

# Reinstall plugin if needed
/plugin update sc@superclaude-official
```

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

### Streaming Mode Execution Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

Example output of the streaming mode in action for a new project.

```bash
/sc:sc:recommend --stream "I'm building a new e-commerce site"

🚀 STREAMING MODE ACTIVE
📊 Project: E-commerce website
⏱️ Estimated Time: 3-6 weeks

--- PHASE 1: ANALYSIS & PLANNING ---
✅ Current: /sc:sc:analyze --seq --c7 --persona-architect
   "E-commerce architecture and technology selection"

🔄 Next Steps (when completed):
1. /sc:sc:design --api --ddd --seq --ultrathink --persona-architect
2. /sc:sc:build --feature --magic --react --persona-frontend

--- STREAM CONTINUING ---
```

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

### Setup AIRIS MCP Gateway

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Install and configure the AIRIS MCP Gateway for unified tool access.

```bash
# 1. Install airis-workspace CLI
brew install agiletec-inc/tap/airis-workspace

# 2. Clone and start the Gateway
git clone https://github.com/agiletec-inc/airis-mcp-gateway.git
cd airis-mcp-gateway
airis up

# 3. Connect to Claude Code
claude mcp add --transport http airis-mcp-gateway http://api.gateway.localhost:9400/api/v1/mcp
```

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

### Systematic Product Discovery Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-brainstorm.md

Initiates a deep, systematic exploration for an AI-powered project management tool. This example leverages multi-persona analysis (architect, analyzer, project-manager) and the Sequential MCP for a structured exploration framework.

```bash
/sc:sc:brainstorm "AI-powered project management tool" --strategy systematic --depth deep
# Multi-persona analysis: architect (system design), analyzer (feasibility), project-manager (requirements)
# Sequential MCP provides structured exploration framework
```

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

### Agent Examples

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-sc.md

Example usage of the agent command with different types.

```text
/sc:sc:agent deep-research
/sc:sc:agent self-review
/sc:sc:agent repo-index
```

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

### SuperClaude Command Quick Start

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Common commands to interact with the SuperClaude plugin after installation.

```shell
# See all commands
/sc:help

# Start brainstorming
/sc:brainstorm "your project idea"

# Analyze codebase
/sc:analyze

# Deep research
/sc:research "your topic"
```

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

### React Component Implementation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-implement.md

Example command for generating a React UI component using Magic MCP and frontend persona best practices.

```text
/sc:sc:implement user profile component --type component --framework react
# Magic MCP generates UI component with design system integration
# Frontend persona ensures best practices and accessibility
```

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

### Self-Improvement Integration Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-pm.md

Example of documenting a successful implementation by creating a pattern file and updating memory.

```python
write_memory("learning/patterns/[name]", reusable_pattern)
```

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

### Record Current State Before Installation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/BACKUP_GUIDE.md

Documents existing MCP servers and plugins to a text file for reference.

```bash
# Document what MCP servers you currently have
claude mcp list > ~/claude-backups/mcp-before.txt

# Document installed plugins
/plugin list > ~/claude-backups/plugins-before.txt
```

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

### Install Individual MCP Server Dependencies

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Install uv to manage individual MCP servers.

```bash
# Install uvx (required for individual MCP servers)
pip install uv
# or
brew install uv
```

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

### Verify SuperClaude Plugin Installation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/BACKUP_GUIDE.md

Commands to check if the SuperClaude plugin is loaded and to initiate its setup wizard and verify MCP status.

```bash
# Check plugin is loaded
/plugin list | grep sc

# Run setup wizard
/sc:setup-mcp

# Check MCP status
/sc:verify-mcp
```

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

### Install SuperClaude Plugin

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/BACKUP_GUIDE.md

Adds the marketplace source and installs the SuperClaude plugin.

```bash
# Add marketplace
/plugin marketplace add SuperClaude-Org/SuperClaude_Plugin

# Install plugin
/plugin install sc@superclaude
```

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

### Cross-Domain Infrastructure Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-spawn.md

Example of spawning an infrastructure task that spans DevOps, Security, and Quality domains with parallel execution.

```bash
/sc:sc:spawn "establish CI/CD pipeline with security scanning"
# System-wide infrastructure operation spanning DevOps, Security, Quality domains
# Parallel execution of independent components with validation gates
```

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

### MCP Server Architecture Overview

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/setup-mcp.md

Displays an overview of the SuperClaude MCP Gateway and its available tools, categorized into essential and optional features. This is presented at the start of the setup wizard.

```text
🚀 SuperClaude MCP Setup Wizard

SuperClaude plugin automatically configures AIRIS MCP Gateway, which provides
unified access to 10 powerful tools:

Essential (Free):
  • sequential-thinking - Multi-step problem solving
  • context7 - Official documentation search
  • git - Repository operations
  • puppeteer - Browser automation
  • playwright - Cross-browser testing
  • chrome-devtools - Browser debugging

Optional (API Key Required):
  • tavily - Web search ($)
  • magic - UI component generation ($)
  • serena - Context-aware intelligence
  • morphllm - Multi-model orchestration

Let's verify your setup...
```

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

### Check uvx Installation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/setup-mcp.md

Verifies if the 'uvx' command-line tool is installed and accessible in the system's PATH. If not, it provides instructions for installation using pip or Homebrew.

```bash
# Check uvx installation
if command -v uvx &> /dev/null; then
    echo "✅ uvx is installed ($(uvx --version))"
else
    echo "❌ uvx is not installed"
    echo ""
    echo "Install with:"
    echo "  pip install uv"
    echo "  # or"
    echo "  brew install uv"
fi
```

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

### Repository Index Summary Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/sc-repo-index.md

This is an example of a compact brief generated by the Repository Index Agent, highlighting directory structures and upcoming tasks. Use this format to keep responses short and data-driven.

```text
📦 Summary:
  - Code: src/superclaude (42 files), pm/ (TypeScript agents)
  - Tests: tests/pm_agent, pytest plugin smoke tests
  - Docs: docs/developer-guide, PROJECT_INDEX.md (to be regenerated)
🔄 Next: create PROJECT_INDEX.md (94% token savings vs raw scan)
```

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

### Example Interaction with Output Format Selection

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/output-architect.md

This example demonstrates how a user can specify the desired output format for a SuperClaude command via the CLI. It shows the confirmation and validation steps.

```text
User: /sc:implement auth --output-format json

Output Architect: ✓ JSON format selected
Schema: superclaude-output-v1.0.0
Validation: ✓ Passed

[JSON output follows...]

💡 Tip: Add --validate flag to see detailed schema compliance report.
```

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

### MCP Configuration Merge Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/docs/SYNC_SYSTEM.md

Demonstrates how Framework and Plugin MCP server configurations are merged, with Framework settings taking precedence.

```json
{
  "mcpServers": {
    "sequential": {
      "command": "uvx",
      "args": ["--from", "git+https://...", "sequential-thinking"]
    },
    "context7": {
      "command": "uvx",
      "args": ["context7-mcp"]
    }
  }
}
```

```json
{
  "mcpServers": {
    "sequential": {
      "command": "npx",
      "args": ["sequential"]
    },
    "airis-mcp-gateway": {
      "command": "uvx",
      "args": ["airis-mcp-gateway"]
    }
  }
}
```

```json
{
  "mcpServers": {
    "sequential": {
      "command": "uvx",
      "args": ["--from", "git+https://...", "sequential-thinking"]
    },
    "context7": {
      "command": "uvx",
      "args": ["context7-mcp"]
    },
    "airis-mcp-gateway": {
      "command": "uvx",
      "args": ["airis-mcp-gateway"]
    }
  }
}
```

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

### Command Transformation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/docs/SYNC_SYSTEM.md

Demonstrates the transformation of command headers and cross-references from the Framework source to the Plugin destination.

```markdown
---
description: Interactive requirements discovery
---

# /brainstorm - Brainstorming

Use /analyze for analysis and [/task] for task management.
```

```markdown
---
description: Interactive requirements discovery
---

# /sc:brainstorm - Brainstorming

Use /sc:analyze for analysis and [/sc:task] for task management.
```

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

### Verify MCP Setup

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README-zh.md

Use these commands to configure and check the status of the MCP server.

```shell
/sc:setup-mcp   # 交互式设置向导
/sc:verify-mcp  # 检查 MCP 状态
```

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

### SuperClaude Command Examples with Output Formats

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/output-architect.md

These examples demonstrate how to use the --output-format flag with specific SuperClaude commands and redirecting output. The last example pipes JSON output to `jq` for further processing.

```bash
/sc:implement feature --output-format json
```

```bash
/sc:analyze codebase --output-format yaml > analysis.yml
```

```bash
/sc:test suite --output-format json | jq '.result.tests_written'
```

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

### Troubleshoot uvx Installation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/setup-mcp.md

Provides solutions for the 'uvx not found' issue, including installation commands for pip and Homebrew, and a verification step.

```bash
# Solution 1: Install via pip
pip install uv

# Solution 2: Install via Homebrew (macOS)
brew install uv

# Verify installation
uvx --version
```

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

### Process Flow Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/modes/MODE_Token_Efficiency.md

Shows how to represent a multi-step process using symbols for completion, progress, and sequence.

```text
Standard: "Build process completed successfully, now running tests, then deploying"
Token Efficient: "build ✅ » test 🔄 » deploy ⏳"
```

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

### Complex Feature Implementation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-spawn.md

Example of spawning a feature implementation task, which triggers a breakdown across database, backend, frontend, and testing domains.

```bash
/sc:sc:spawn "implement user authentication system"
# Breakdown: Database design → Backend API → Frontend UI → Testing
# Coordinates across multiple domains with dependency management
```

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

### Large-Scale System Operation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-spawn.md

Example of an enterprise-scale migration operation using the adaptive strategy and deep depth setting.

```bash
/sc:sc:spawn "migrate legacy monolith to microservices" --strategy adaptive --depth deep
# Enterprise-scale operation with sophisticated orchestration
# Adaptive coordination based on operation characteristics
```

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

### Documentation Command Output Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/documentation-specialist.md

Sample console output generated by the /sc:document command.

```markdown
📚 **Documentation Generation Started**

Analyzing project structure...
✓ Found 234 files across 47 modules

### 📋 Documentation Plan
1. README.md - Project overview
2. docs/api/ - API reference (47 modules)
3. docs/guides/ - User guides (5 topics)
4. docs/architecture/ - System diagrams
5. CHANGELOG.md - Version history

Estimated time: 3-5 minutes

### 🔄 Progress

[████████████████░░░░] 80%

✓ README.md generated (2.3s)
✓ API documentation (187 functions, 34 classes) (15.7s)
✓ Architecture diagrams (3 diagrams) (4.2s)
⏳ User guides (3/5 complete)
⏳ Changelog (processing 247 commits)

### 📊 Results

**Files Created**: 73 documentation files
**Total Size**: 1.2 MB
**Coverage**: 95% of codebase documented

### 📁 Output Structure
```
docs/
├── api/
│   ├── auth.md
│   ├── database.md
│   └── services.md
├── guides/
│   ├── quickstart.md
│   ├── authentication.md
│   └── deployment.md
├── architecture/
│   ├── overview.md
│   ├── database-schema.svg
│   └── api-flow.svg
└── README.md

CHANGELOG.md
```

✅ **Documentation Complete!**

View documentation: docs/README.md
Serve locally: `python -m http.server --directory docs`
```

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

### Comprehensive Recommendation Execution

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

Example of executing a recommendation request with multiple flags and the resulting output format.

```bash
/sc:sc:recommend "I'm building an e-commerce site" --estimate --alternatives --community

🎯 COMPREHENSIVE ANALYSIS
==========================

📊 Project Analysis: E-commerce website development
🌍 Language: Turkish detected
📁 Project Context: New project (no existing project)
🎭 Persona: --persona-architect + --persona-frontend + --persona-security
🔍 Category: Web development + E-commerce + Security-focused

✅ BEST RECOMMENDATIONS
=================

1. 🏗️ PLANNING AND DESIGN
   /sc:sc:design --api --ddd --seq --ultrathink --persona-architect
   "E-commerce domain architecture and system design"

2. 🎨 FRONTEND DEVELOPMENT
   /sc:sc:build --feature --magic --nextjs --persona-frontend
   "Modern, SEO-friendly e-commerce frontend"

3. 🔒 SECURITY AND BACKEND
   /sc:sc:build --feature --tdd --persona-security
   "Secure payment system and user management"

🔧 SMART FLAG RECOMMENDATIONS
======================

📚 Learning mode: --tutorial --examples (if you're just starting)
🚀 Quick start: --quick-start --template (e-commerce template)
🔒 Security-focused: --security --owasp --strict (for payment transactions)
⚡ Performance: --optimize --monitoring --cdn (for high traffic)

🔧 ALTERNATIVE TECHNOLOGIES
==========================

⭐ BEST: Next.js + Stripe + PostgreSQL
   ✅ Advantage: Modern stack, great SEO, scalable
   👥 Community: 42% prefer this

🥈 SECOND: Vue.js + Shopify API + Headless CMS
   ✅ Advantage: Faster development, good DX
   👥 Community: 18% prefer this

🥉 THIRD: React + Custom Backend + MongoDB
   ✅ Advantage: Maximum flexibility, full control
   👥 Community: 15% prefer this

⏱️ TIME AND BUDGET ESTIMATE
========================

📅 Project Duration: 6-12 weeks
- Planning & Design: 1-2 weeks
- Frontend Development: 2-4 weeks
- Backend & Payment: 2-3 weeks
- Testing & Security: 1-2 weeks
- Deployment & Launch: 0.5-1 week

💰 Budget Estimate:
- Solo Developer: 240-480 hours
- Small Team (2-3 people): 480-1440 hours
- Enterprise Team: 1440-2880 hours

👥 COMMUNITY DATA
==================

🏆 Most Successful Flow:
/sc:sc:analyze → /sc:sc:design → /sc:sc:build → /sc:sc:test → /sc:sc:deploy
Success Rate: 87% (from 2,847 projects)

📈 Popular Features:
- User authentication: 94% of projects have it
- Payment integration: 89% of projects have it
- Admin panel: 76% of projects have it
- Inventory management: 68% of projects have it

⚠️ COMMON RISKS:
- Payment security issues: 32% of projects experienced
- Performance scaling: 28% of projects had issues
- Tax calculation complexity: 45% of projects struggled

🚀 ADDITIONAL SUPER RECOMMENDATIONS
===================

💡 Premium Features (+2-4 weeks):
- Multi-vendor marketplace
- Advanced analytics dashboard
- Mobile app (React Native)
- AI-powered recommendations

🔒 Enterprise Security (+1-2 weeks):
- SOC 2 compliance
- Advanced fraud detection
- PCI DSS certification
- Security audit package

📱 Omnichannel Support (+2-3 weeks):
- PWA capabilities
- Mobile-first design
- Social media integration
- Progressive web app

🔄 STREAMING MODE CAN BE ACTIVATED
===================================

To receive continuous recommendations throughout the project:
/sc:sc:recommend --stream "track my e-commerce project"

You'll receive automatic recommendations at each stage! 🚀
```

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

### Correct Directory Structure Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/core/RULES.md

Illustrates a correct logical directory structure organized by feature/domain.

```plaintext
components/auth/
```

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

### Memory Key Schema Examples

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-pm.md

Examples of how to use the write_memory function with different memory key patterns for various stages of development.

```python
write_memory("session/checkpoint", current_state)
```

```python
write_memory("plan/auth/hypothesis", hypothesis_doc)
```

```python
write_memory("execution/auth/do", experiment_log)
```

```python
write_memory("evaluation/auth/check", analysis)
```

```python
write_memory("learning/patterns/supabase-auth", success_pattern)
```

```python
write_memory("learning/solutions/jwt-config-error", solution)
```

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

### Install SuperClaude Plugin

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Add the marketplace and install the SuperClaude plugin within Claude Code.

```shell
# Add the SuperClaude marketplace
/plugin marketplace add SuperClaude-Org/SuperClaude_Plugin

# Install the plugin
/plugin install sc@SuperClaude-Org

# Restart Claude Code to activate
```

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

### Correct Planning Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/core/RULES.md

An example of a correct planning approach that identifies parallelizable tasks, sequential dependencies, and subsequent parallel operations.

```plaintext
Plan: 1) Parallel: [Read 5 files] 2) Sequential: analyze → 3) Parallel: [Edit all files]
```

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

### Documentation Command Usage

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/documentation-specialist.md

Syntax and examples for the /sc:document CLI command.

```markdown
# Usage
/sc:document <type> [target] [--flags]

# Types
- `generate` - Full documentation suite
- `api` - API reference from code
- `readme` - README.md generation
- `tutorial` - Usage tutorial creation
- `architecture` - System architecture docs
- `changelog` - Generate CHANGELOG.md
- `migration` - Migration guide for version update

# Targets
- File path, directory, or module name
- Examples: `src/api/`, `auth.jwt_handler`, `main.py`

# Flags
- `--lang <code>` - Language (en, ja, zh, ko). Default: en
- `--format <type>` - Output format (md, html, pdf). Default: md
- `--update` - Update existing docs instead of creating new
- `--interactive` - Interactive mode with prompts
- `--output <path>` - Custom output directory

# Examples

## Generate Complete Documentation Suite
/sc:document generate

## API Documentation for Module
/sc:document api src/api/ --format html

## README for Project
/sc:document readme --interactive

## Tutorial for Feature
/sc:document tutorial authentication

## Architecture with Diagrams
/sc:document architecture --format pdf

## Changelog from Git History
/sc:document changelog --since v1.0.0

## Japanese Documentation
/sc:document api src/auth/ --lang ja

## Update Existing Docs
/sc:document api src/api/ --update
```

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

### Auto-Documentation Integration

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/documentation-specialist.md

Example hook to trigger documentation generation automatically after a successful implementation command.

```python
# Auto-generate docs after implementation
@after_command("/sc:implement")
def auto_document(result):
    if result.status == "success":
        doc_specialist.generate_api_docs(
            target=result.files_created,
            update_existing=True
        )
```

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

### Memory Management Operation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-select-tool.md

Demonstrates direct mapping for memory-related operations.

```bash
/sc:sc:select-tool "save project context and discoveries"
# Direct mapping: Memory operations → Serena MCP
# Rationale: Project context and cross-session persistence
```

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

### Verify MCP Setup

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Use built-in commands to configure and check the status of MCP servers.

```shell
/sc:setup-mcp   # Interactive setup wizard
/sc:verify-mcp  # Check MCP status
```

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

### Command with Expertise Level

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

Use this command to get recommendations tailored to a specific expertise level, such as 'beginner' for learning a new technology like React.

```bash
/sc:sc:recommend "I want to learn React" --expertise beginner
```

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

### Basic Command Usage

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

Use this command to get recommendations for a general task. It's the most basic way to interact with the recommender.

```bash
/sc:sc:recommend "I want to do something"
```

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

### Basic Business Panel Usage

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/core/BUSINESS_PANEL_EXAMPLES.md

Examples of invoking the business panel with documents, specific topics, and different operational modes.

```bash
/sc:business-panel @strategy_doc.pdf
```

```bash
/sc:business-panel "We're developing AI-powered customer service" --experts "christensen,drucker,godin"
```

```bash
/sc:business-panel @risk_assessment.md --mode debate
```

```bash
/sc:business-panel "Help me understand competitive strategy" --mode socratic
```

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

### Research Command Examples

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-research.md

Common usage examples for the research command, demonstrating basic queries and optional flag configurations.

```text
/sc:sc:research "latest developments in quantum computing 2024"
/sc:sc:research "competitive analysis of AI coding assistants" --depth deep
/sc:sc:research "best practices for distributed systems" --strategy unified
```

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

### Pattern-Based Bulk Edit Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-select-tool.md

Demonstrates selection for speed-prioritized, pattern-based transformations.

```bash
/sc:sc:select-tool "update console.log to logger.info across project" --explain
# Analysis: Pattern-based transformation, speed priority
# Selection: Morphllm MCP (pattern matching, bulk operations)
```

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

### Dynamic Context Markdown Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/context-orchestrator.md

An example of the auto-generated DYNAMIC_CONTEXT.md file, showcasing the structured information captured about the project, time, and user. This context is dynamically updated and used by the agent.

```markdown
# Dynamic Context (Auto-Updated)
Last Updated: 2025-10-11 15:30:00 JST

## 🕐 Time Context
- **Current Time**: 2025-10-11 15:30:00 JST
- **Session Start**: 2025-10-11 15:00:00 JST
- **Session Duration**: 30 minutes
- **Timezone**: Asia/Tokyo (UTC+9)
- **Working Hours**: Yes (Business hours)

## 📁 Project Context
- **Project Name**: MyFastAPIApp
- **Root Path**: /home/user/projects/my-fastapi-app
- **Primary Language**: Python 3.11
- **Framework**: FastAPI 0.104.1
- **Package Manager**: poetry
- **Git Branch**: feature/jwt-auth
- **Git Status**: 3 files changed, 245 insertions(+), 12 deletions(-)

### Recent File Activity (Last 24 Hours)
| File | Action | Time |
|------|--------|------|
| src/auth/jwt_handler.py | Modified | 2h ago |
| tests/test_jwt_handler.py | Created | 2h ago |
| src/api/routes.py | Modified | 5h ago |
| requirements.txt | Modified | 5h ago |

### Dependencies (47 packages)
- **Core**: fastapi, pydantic, uvicorn
- **Auth**: pyjwt, passlib, bcrypt
- **Database**: sqlalchemy, alembic
- **Testing**: pytest, pytest-asyncio
- **Dev**: black, mypy, flake8

```

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

### Session Start Protocol (YAML)

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-pm.md

Defines the steps executed automatically at the start of each session to restore context and report status to the user.

```yaml
1. Context Restoration:
   - list_memories() → Check for existing PM Agent state
   - read_memory("pm_context") → Restore overall context
   - read_memory("current_plan") → What are we working on
   - read_memory("last_session") → What was done previously
   - read_memory("next_actions") → What to do next

2. Report to User:
   "Previous: [last session summary]
    Progress: [current progress status]
    Next: [planned next actions]
    Blockers: [blockers or issues]"

3. Ready for Work:
   User can immediately continue from last checkpoint
   No need to re-explain context or goals
```

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

### Performance Analysis Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/modes/MODE_Token_Efficiency.md

Demonstrates using symbols to concisely explain performance issues related to algorithm complexity.

```text
Standard: "Performance analysis shows the algorithm is slow because it's O(n²) complexity"
Token Efficient: "⚡ perf analysis: slow ∵ O(n²) complexity"
```

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

### Example MCP Servers Configuration

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/BACKUP_GUIDE.md

Illustrates how custom MCP servers coexist with the AIRIS MCP Gateway added by the plugin. Custom servers remain in your settings file.

```json
{
  "mcpServers": {
    "airis-mcp-gateway": { ... },    // Added by plugin
    "my-custom-server": { ... }       // Your custom server (safe!)
  }
}
```

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

### Pre-Implementation Context Gathering YAML

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/sc-pm-agent.md

Checklist for verifying that necessary documentation and context have been reviewed before starting implementation.

```yaml
Pre-Implementation:
  - Verify specialist agents have read CLAUDE.md
  - Ensure docs/*.md were consulted
  - Confirm existing implementations were searched
  - Validate public documentation was checked
```

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

### SuperClaude Plugin Quick Start Commands

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/CLAUDE.md

After installation and restarting Claude Code, use these commands to access SuperClaude functionalities like help, project brainstorming, code analysis, and deep research.

```shell
# See all available commands
/sc:help

# Start a new project
/sc:brainstorm "your project idea"

# Analyze codebase
/sc:analyze

# Deep research
/sc:research "your topic"
```

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

### Brainstorming Mode Interaction Examples

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/modes/MODE_Brainstorming.md

Illustrates how the system transforms standard user requests into structured discovery questions and requirement briefs.

```text
Standard: "I want to build a web app"
Brainstorming: "🤔 Discovery Questions:
               - What problem does this solve for users?
               - Who are your target users and their main workflows?
               - What's your expected user volume and performance needs?
               - Any existing systems to integrate with?
               📝 Brief: [Generate structured requirements document]"

Standard: "Maybe we could improve the authentication system"
Brainstorming: "🔍 Let's explore this together:
               - What specific auth challenges are users facing?
               - Current vs desired user experience?
               - Security requirements and compliance needs?
               - Timeline and resource constraints?
               ✅ Outcome: Clear improvement roadmap"
```

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

### Session Progress Analysis Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-reflect.md

This command performs a comprehensive analysis of session work and information gathering, assessing quality and identifying gaps for project improvement.

```bash
/sc:sc:reflect --type session --validate
# Comprehensive analysis of session work and information gathering
# Quality assessment and gap identification for project improvement
```

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

### Install SuperClaude Plugin

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/CLAUDE.md

Use these commands to add and install the SuperClaude plugin from the marketplace. Restart Claude Code after installation.

```shell
/plugin marketplace add SuperClaude-Org/SuperClaude_Plugin
/plugin install sc@superclaude
```

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

### Task Adherence Reflection Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-reflect.md

Use this command to validate the current approach against project goals and identify deviations. It provides course correction recommendations.

```bash
/sc:sc:reflect --type task --analyze
# Validates current approach against project goals
# Identifies deviations and provides course correction recommendations
```

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

### Research Examples

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-sc.md

Example queries for the research command.

```text
/sc:sc:research React 18 new features
/sc:sc:research LLM agent architectures 2024
/sc:sc:research Python async best practices
```

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

### Standard Project Build

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-build.md

Executes a full project build using default configurations and generates a report.

```bash
/sc:sc:build
# Builds entire project using default configuration
# Generates artifacts and comprehensive build report
```

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

### Create Knowledge Base

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-index.md

Initiate interactive knowledge base generation using project-specific patterns. The Architect persona guides structural organization and cross-referencing.

```bash
/sc:sc:index . --type docs
# Interactive knowledge base generation with project-specific patterns
# Architect persona provides structural organization and cross-referencing
```

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

### Security Hardening Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-improve.md

Identifies vulnerabilities in the authentication service and applies security patterns, followed by comprehensive validation to ensure effectiveness. The security persona leads this process.

```bash
/sc:sc:improve auth-service --type security --validate
# Security persona identifies vulnerabilities and applies security patterns
# Comprehensive validation ensures security improvements are effective
```

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

### Performance Optimization Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-improve.md

Initiates performance analysis on API endpoints, with interactive guidance for complex optimization decisions. The performance persona identifies bottlenecks and opportunities.

```bash
/sc:sc:improve api-endpoints --type performance --interactive
# Performance persona analyzes bottlenecks and optimization opportunities
# Interactive guidance for complex performance improvement decisions
```

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

### Completion Validation Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-reflect.md

This command evaluates task completion criteria against actual progress, determining readiness for task completion and identifying any remaining blockers.

```bash
/sc:sc:reflect --type completion
# Evaluates task completion criteria against actual progress
# Determines readiness for task completion and identifies remaining blockers
```

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

### Basic Project Loading

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-load.md

Loads the current directory project context and establishes session context.

```bash
/sc:sc:load
# Loads current directory project context with Serena memory integration
# Establishes session context and prepares for development workflow
```

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

### Install SuperClaude Plugin in Claude Code

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/MIGRATION_GUIDE.md

Commands to install the SuperClaude plugin directly within the Claude Code environment. Use the marketplace command first, then the install command.

```shell
# In Claude Code
/plugin marketplace add SuperClaude-Org/SuperClaude_Plugin
/plugin install superclaude@SuperClaude-Org
```

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

### Install uvx and Restart Claude Code

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/BACKUP_GUIDE.md

Instructions to check if uvx is installed, install it using pip if necessary, and then restart Claude Code. This is part of troubleshooting MCP server issues.

```bash
# 1. Check uvx is installed
uvx --version

# If not installed:
pip install uv

# 2. Restart Claude Code
# 3. Run setup wizard
/sc:setup-mcp
```

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

### Maintainability Improvements Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-improve.md

Analyzes legacy modules for maintainability improvements, with the architect persona suggesting changes. The preview mode allows for reviewing suggested changes before application.

```bash
/sc:sc:improve legacy-modules --type maintainability --preview
# Architect persona analyzes structure and suggests maintainability improvements
# Preview mode shows changes before application for review
```

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

### Incorrect Directory Structure Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/core/RULES.md

Example of an incorrect or overly generic directory structure.

```plaintext
files/everything/
```

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

### Command with Estimation and Alternatives

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-recommend.md

This command requests recommendations for a new React project and includes options to estimate time/budget and explore alternative solutions.

```bash
/sc:sc:recommend "new React project" --estimate --alternatives
```

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

### Uninstall Legacy Versions

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Remove previous installations of SuperClaude before installing the new plugin version.

```bash
# For pip users
pip uninstall SuperClaude

# For pipx users
pipx uninstall SuperClaude

# For npm users
npm uninstall -g @bifrost_inc/superclaude

# For uv users
uv tool uninstall SuperClaude
```

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

### Framework Concept Explanation Command

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-explain.md

Explains framework concepts like React hooks with intermediate detail, utilizing Context7 for official documentation patterns. The explanation is structured with progressive complexity.

```bash
/sc:sc:explain react-hooks --level intermediate --context react
# Context7 integration for official React documentation patterns
# Structured explanation with progressive complexity
```

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

### Incorrect Naming Conventions Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/core/RULES.md

Example of incorrect naming conventions, mixing casing styles within a project.

```plaintext
get_userData()
```

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

### Command Usage Syntax

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-load.md

General syntax for invoking the project context loading command.

```bash
/sc:sc:load [target] [--type project|config|deps|checkpoint] [--refresh] [--analyze]
```

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

### Incorrect Planning Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/core/RULES.md

An example of an incorrect planning approach that lists operations sequentially without identifying parallelization opportunities.

```plaintext
Plan: Read file1 → Read file2 → Read file3 → analyze → edit file1 → edit file2
```

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

### Session Start Protocol

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/sc-pm-agent.md

Defines the mandatory context restoration steps executed at the start of every Claude Code session.

```yaml
Activation Trigger:
  - EVERY Claude Code session start (no user command needed)
  - "where did we leave off", "current status", "progress" queries

Context Restoration:
  1. list_memories() → Check for existing PM Agent state
  2. read_memory("pm_context") → Restore overall project context
  3. read_memory("current_plan") → What are we working on
  4. read_memory("last_session") → What was done previously
  5. read_memory("next_actions") → What to do next

User Report:
  Previous: [last session summary]
  Progress: [current progress status]
  Next: [planned next actions]
  Blockers: [blockers or issues]

Ready for Work:
  - User can immediately continue from last checkpoint
  - No need to re-explain context or goals
  - PM Agent knows project state, architecture, patterns
```

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

### ReAct Pattern Reasoning Process Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/context-orchestrator.md

Illustrates the ReAct pattern's thought-action-observation cycles for implementing JWT authentication. Shows how the agent reasons through dependency checks and external best practices.

```markdown
## 🤔 Reasoning Process (ReAct Pattern)

### 💭 Thought 1
User wants to implement JWT authentication. Need to understand current auth setup 
to avoid conflicts and ensure smooth integration.

### 📋 Plan 1
1. Search for existing auth code in the project
2. Check for JWT library dependencies
3. Review security best practices for JWT
4. Design integration approach

### 🔍 Action 1: Vector Search
Searching project for: "authentication existing implementation"

### 👁️ Observation 1
Found 3 relevant files:
- **src/auth/basic_auth.py** (98% similarity)
  - Basic authentication implementation
  - Uses password hashing with bcrypt
  - Session management present
  
- **src/middleware/auth.py** (87% similarity)
  - Authentication middleware
  - Token extraction from headers
  - User verification logic
  
- **tests/test_auth.py** (76% similarity)
  - Existing auth tests
  - Test fixtures for users
  - Mock authentication scenarios

### 💡 Reflection 1
Project has basic auth infrastructure. JWT can be integrated alongside rather than 
replacing it. This allows gradual migration and backward compatibility.

### 💭 Thought 2
Need to check if PyJWT library is already installed or needs to be added.

### 🔍 Action 2: Check Dependencies
Reading requirements.txt and pyproject.toml

### 👁️ Observation 2
**Current Dependencies**:
- passlib[bcrypt]==1.7.4 ✓
- python-jose==3.3.0 ✓ (includes JWT support)
- python-multipart==0.0.6 ✓

**Analysis**: python-jose already provides JWT functionality. No new dependency needed!

### 💡 Reflection 2
Can use existing python-jose library. This reduces dependency footprint and 
simplifies implementation.

### 📋 Plan 2 (Refined)
1. Create JWT handler using python-jose
2. Update middleware to support both basic auth and JWT
3. Add comprehensive tests
4. Maintain backward compatibility
5. Document migration path

### 🔍 Action 3: Semantic Search for Best Practices
Searching external sources: "JWT authentication FastAPI best practices 2025"

### 👁️ Observation 3
**Key Best Practices**:
- Use short-lived access tokens (15 minutes)
- Implement refresh tokens for session extension
- Store JWT secret in environment variables
- Add token blacklist for logout
- Use proper CORS configuration
- Implement rate limiting

### 🎯 Final Plan
Based on analysis, implementing JWT with:
1. Access tokens (15 min expiry)
2. Refresh tokens (7 day expiry)
3. Token blacklist using Redis
4. Backward-compatible middleware
5. Comprehensive test suite

Proceeding with implementation...

```

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

### Install JWT Dependencies

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/agents/ContextEngineering/documentation-specialist.md

Install necessary Python packages for JWT authentication using Poetry. Includes pyjwt and passlib with bcrypt support.

```bash
poetry add pyjwt passlib[bcrypt]
```

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

### Uninstall SuperClaude via Pip

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/MIGRATION_GUIDE.md

Commands to uninstall SuperClaude when it was installed using pip or pipx. Ensure you have the correct command for your installation method.

```bash
pip uninstall SuperClaude
# or
pipx uninstall SuperClaude
```

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

### Generate API Reference Documentation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-document.md

Create detailed API documentation, including endpoints, schemas, usage examples, and integration guidelines, by specifying the target directory and setting the type to 'api' with a 'detailed' style.

```bash
/sc:sc:document src/api --type api --style detailed
# Creates comprehensive API documentation with endpoints and schemas
# Generates usage examples and integration guidelines
```

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

### Uninstall Previous SuperClaude Versions

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/CLAUDE.md

If you previously installed SuperClaude using pip or npm, use these commands to uninstall those versions before installing the plugin version.

```bash
# Uninstall pip version
pip uninstall SuperClaude

# Uninstall npm version
npm uninstall -g @bifrost_inc/superclaude
```

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

### Build Command Syntax

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-build.md

General syntax for triggering project builds with optional environment and optimization flags.

```bash
/sc:sc:build [target] [--type dev|prod|test] [--clean] [--optimize] [--verbose]
```

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

### Basic Code Explanation Command

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-explain.md

Use this command for a basic explanation of a JavaScript file, optimized for beginners. The educator persona ensures a learning-focused structure.

```bash
/sc:sc:explain authentication.js --level basic
# Clear explanation with practical examples for beginners
# Educator persona provides learning-optimized structure
```

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

### Verify SuperClaude Plugin Installation

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/MIGRATION_GUIDE.md

Commands to verify that the SuperClaude plugin has been successfully installed and is recognized by Claude Code. Check available commands and test basic functionality.

```shell
# Check available commands
/sc:help

# Test basic functionality
/sc:analyze --help
```

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

### Cross-Session Refinement Example

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-brainstorm.md

Facilitates iterative refinement of a mobile app monetization strategy with normal depth. This scenario relies on Serena MCP for managing cross-session context and progressive dialogue enhancement with memory-driven insights.

```bash
/sc:sc:brainstorm "mobile app monetization strategy" --depth normal
# Serena MCP manages cross-session context and iterative refinement
# Progressive dialogue enhancement with memory-driven insights
```

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

### Install AIRIS Agent Plugin

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/README.md

Add the AIRIS Agent plugin to your marketplace and then install it. This plugin offers features like repository indexing, confidence checks, deep research, and self-review.

```bash
/plugin marketplace add agiletec-inc/airis-agent
/plugin install airis-agent
```

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

### Help Command

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-sc.md

Displays all available commands.

```text
/sc:sc                         - Show this help (all available commands)
```

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

### Main Help Command

Source: https://github.com/superclaude-org/superclaude_plugin/blob/main/commands/sc-sc.md

Accessing the main help menu.

```text
/sc:sc
```
Tokens:
Raw