Skip to main content
command CX Codex

recommend · superclaude-org — Claude Code command: what it does, how to install

The recommend command maps a user request to suitable SuperClaude commands. Use it when you need help choosing a workflow, persona, or flag.

MIT ★ 23,950 updated 2026-09-27

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/commands/recommend.md
Open on GitHub

What recommend does

recommend parses the request, extracts keywords, and assigns it to a task group such as ML, web development, debugging, testing, or security. It then maps that group to SuperClaude commands, personas, flags, and MCP server options. Suggested results can include /sc:analyze, /sc:build, or /sc:troubleshoot.

The command checks for English and Turkish language patterns; when those checks do not match, it falls back to English. Its invocation is /sc:recommend [user request] --options [flags]. The output follows the SuperClaude command map, so the suggestions are tied to that command set rather than being general Claude Code actions.

What it helps with

  • choose a SuperClaude command for a plain-language request
  • match a task with a suitable persona and flags
  • classify a request by development area
  • find a workflow for debugging or testing

Example prompts for the agent

  • Use /sc:recommend "my website is slow" and suggest the right SuperClaude command.
  • Recommend a command for adding a new feature, including the relevant persona and flags.
  • I am getting an error when the project starts. Which SuperClaude command should I use?

How to install recommend

Manually: put the files in place

.claude/commands/recommend.md

Call it with /recommend. For all projects use ~/.claude/commands/

Questions about recommend

How do I install recommend in Claude Code?

Place the file at .claude/commands/recommend.md.

What does recommend do?

It analyzes a user request, selects a task category, and suggests SuperClaude commands with matching personas, flags, and MCP server options.

Which languages does recommend detect?

It has explicit detection for English and Turkish. Other input falls back to English.

Source text

recommend.md · MIT
---
name: sc:recommend
description: Ultra-intelligent command recommendation engine - recommends the most suitable SuperClaude commands for any user input
category: utility
---

# SuperClaude Intelligent Command Recommender

**Purpose**: Ultra-intelligent command recommendation engine - recommends the most suitable SuperClaude commands for any user input

## Command Definition

```bash
/sc:recommend [user request] --options [flags]
```

## Multi-language Support

### Language Detection and Translation System

```yaml
language_mapping:
  turkish_keywords:
    machine_learning: ["machine learning", "ml", "artificial intelligence", "ai"]
    website: ["website", "web site", "site", "page"]
    application: ["app", "application", "program", "software"]
    error: ["error", "bug", "issue", "problem"]
    performance: ["performance", "speed", "fast", "optimization"]
    new: ["new", "create", "build", "start", "develop"]
    analysis: ["analyze", "analysis", "examine", "research"]

  english_keywords:
    machine learning: ["machine learning", "artificial intelligence", "ml", "ai"]
    website: ["website", "site", "page", "web application"]
    performance: ["performance", "speed", "optimization", "speed"]
    error: ["error", "issue", "bug", "problem"]

  universal_patterns:
    question_words: ["how", "what", "why", "which"]
    action_words: ["do", "create", "build", "develop"]
    help_words: ["help", "suggest", "recommend", "learn"]
```

### Language Detection Algorithm

```python
def detect_language_and_translate(input_text):
    turkish_chars = ["ç", "ğ", "ı", "ö", "ş", "ü"]
    if any(char in input_text.lower() for char in turkish_chars):
        return "tr"

    english_common = [
        "the",
        "and",
        "is",
        "are",
        "was",
        "were",
        "will",
        "would",
        "could",
        "should",
    ]
    if any(word in input_text.lower().split() for word in english_common):
        return "en"

    return "en"  # Default to English
```

### Multi-language Examples

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

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

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

## SuperClaude Integrated Recommendation Engine

### 1. Keyword Extraction and Persona Matching
```yaml
keyword_extraction:
  pattern_matching:
    # Machine Learning
    - "machine learning|ml|ai|artificial intelligence" → ml_category + --persona-analyzer
    - "data|database|sql" → data_category + --persona-backend
    - "model|algorithm|prediction|classify" → ml_category + --persona-architect

    # Web Development
    - "website|frontend|ui/ux" → web_category + --persona-frontend
    - "react|vue|angular|component" → web_category + --persona-frontend --magic
    - "api|backend|server|microservice" → api_category + --persona-backend

    # Debugging & Performance
    - "error|bug|issue|not working" → debug_category + --persona-analyzer
    - "slow|performance|optimization" → performance_category + --persona-performance
    - "security|auth|vulnerability" → security_category + --persona-security

    # Development
    - "new|create|build|develop|feature" → create_category + --persona-frontend|backend
    - "design|architecture" → design_category + --persona-architect
    - "test|qa|quality|validation" → test_category + --persona-qa

    # Learning
    - "how|learn|explain|tutorial" → learning_category + --persona-mentor
    - "refactor|cleanup|improve|quality" → improve_category + --persona-refactorer

  context_analysis:
    - "beginner|starter|just started" → beginner_level + --persona-mentor
    - "expert|senior|experienced" → expert_level + --persona-architect
    - "continue|resume" → continuity_mode + --seq
    - "next step|what now" → next_step_mode + --think
```

### 2. SuperClaude Command Map
```yaml
category_mapping:
  ml_category:
    primary_commands: ["/sc:analyze --seq --c7", "/sc:design --seq --ultrathink"]
    secondary_commands: ["/sc:build --feature --tdd", "/sc:improve --performance"]
    mcp_servers: ["--c7", "--seq"]
    personas: ["--persona-analyzer", "--persona-architect"]
    flags: ["--think-hard", "--evidence", "--profile"]

  web_category:
    primary_commands: ["/sc:build --feature --magic", "/sc:design --api --seq"]
    secondary_commands: ["/sc:test --coverage --e2e --pup", "/sc:analyze --code"]
    mcp_servers: ["--magic", "--c7", "--pup"]
    personas: ["--persona-frontend", "--persona-qa"]
    flags: ["--react", "--tdd", "--validate"]

  api_category:
    primary_commands: ["/sc:design --api --ddd --seq", "/sc:build --feature --tdd"]
    secondary_commands: ["/sc:scan --security --owasp", "/sc:analyze --performance --pup"]
    mcp_servers: ["--seq", "--c7", "--pup"]
    personas: ["--persona-backend", "--persona-security"]
    flags: ["--microservices", "--ultrathink", "--security"]

  debug_category:
    primary_commands: ["/sc:troubleshoot --investigate --seq", "/sc:analyze --code --seq"]
    secondary_commands: ["/sc:scan --security", "/sc:improve --quality"]
    mcp_servers: ["--seq", "--all-mcp"]
    personas: ["--persona-analyzer", "--persona-security"]
    flags: ["--evidence", "--think-hard", "--profile"]

  performance_category:
    primary_commands: ["/sc:analyze --performance --pup --profile", "/sc:troubleshoot --seq"]
    secondary_commands: ["/sc:improve --performance --iterate", "/sc:build --optimize"]
    mcp_servers: ["--pup", "--seq"]
    personas: ["--persona-performance", "--persona-analyzer"]
    flags: ["--profile", "--monitoring", "--benchmark"]

  security_category:
    primary_commands: ["/sc:scan --security --owasp --deps", "/sc:analyze --security --seq"]
    secondary_commands: ["/sc:improve --security --harden", "/sc:troubleshoot --investigate"]
    mcp_servers: ["--seq"]
    personas: ["--persona-security", "--persona-analyzer"]
    flags: ["--strict", "--validate", "--owasp"]

  create_category:
    primary_commands: ["/sc:build --feature --tdd", "/sc:design --seq --ultrathink"]
    secondary_commands: ["/sc:analyze --code --c7", "/sc:test --coverage --e2e"]
    mcp_servers: ["--magic", "--c7", "--pup"]
    personas: ["--persona-frontend", "--persona-backend", "--persona-architect"]
    flags: ["--interactive", "--plan", "--think"]

  test_category:
    primary_commands: ["/sc:test --coverage --e2e --pup", "/sc:scan --validate"]
    secondary_commands: ["/sc:improve --quality", "/sc:troubleshoot --investigate"]
    mcp_servers: ["--pup"]
    personas: ["--persona-qa", "--persona-performance"]
    flags: ["--validate", "--coverage", "--monitoring"]

  improve_category:
    primary_commands: ["/sc:improve --quality --iterate", "/sc:cleanup --code --all"]
    secondary_commands: ["/sc:analyze --code --seq", "/sc:refactor --quality"]
    mcp_servers: ["--seq"]
    personas: ["--persona-refactorer", "--persona-mentor"]
    flags: ["--threshold", "--iterate", "--profile"]

  learning_category:
    primary_commands: ["/sc:document --user --examples", "/sc:analyze --code --c7"]
    secondary_commands: ["/sc:brainstorm --interactive", "/sc:help --specific"]
    mcp_servers: ["--c7"]
    personas: ["--persona-mentor", "--persona-analyzer"]
    flags: ["--examples", "--visual", "--interactive"]
```

### 3. Expertise Level Detection and Customization
```yaml
expertise_levels:
  beginner:
    style: "detailed, step-by-step, explanatory"
    recommended_commands: ["/sc:brainstorm --educational", "/sc:help --interactive"]
    extra_explanations: true
    step_by_step: true

  intermediate:
    style: "balanced, technical but understandable"
    recommended_commands: ["/sc:implement --guided", "/sc:design --template"]
    some_explanations: true

  expert:
    style: "fast, technical, direct"
    recommended_commands: ["/sc:implement --advanced", "/sc:analyze --deep"]
    minimal_explanations: true
```

## SuperClaude Integrated Real Examples

### Example 1: Beginner Level ML Project
```bash
User: /sc:recommend "I'm new, I want to do machine learning"

🎯 Project Analysis: Machine learning - Beginner level
🌍 Language: Turkish detected
📊 Level: Beginner mode + Mentor persona active
🎭 Persona: --persona-mentor + --persona-analyzer

✅ SuperClaude Recommended Flow:
1. /sc:analyze --seq --c7 --persona-mentor
   "Research ML goals, data types, and suitable libraries"

2. /sc:design --seq --ultrathink --persona-architect
   "Design simple but scalable ML architecture"

3. /sc:build --feature --tdd --persona-frontend
   "Create ML pipeline with TDD"

4. /sc:test --coverage --e2e --pup --persona-qa
   "Create comprehensive test scenarios"

🔧 Recommended MCP Servers: --c7 --seq
💡 Additional Recommendations:
- Learning mode: /sc:document --user --examples --persona-mentor
- Security: /sc:scan --security --owasp (next phase)
- Performance: /sc:analyze --performance --pup (after model training)

🚀 Quick Start (optional):
/sc:build --feature --magic --react --persona-frontend
```

### Example 2: Web Performance Optimization
```bash
User: /sc:recommend "my site is very slow, what should I do?"

🎯 Project Analysis: Web performance optimization - Urgent
🌍 Language: Turkish
📊 Level: Urgent situation + Performance persona
🎭 Persona: --persona-performance + --persona-analyzer

✅ SuperClaude Recommended Flow:
1. /sc:analyze --performance --pup --profile --persona-performance
   "Detailed performance analysis and bottleneck detection"

2. /sc:troubleshoot --investigate --seq --persona-analyzer
   "Investigate issue with root cause analysis"

3. /sc:improve --performance --iterate --persona-performance
   "Data-driven performance improvements"

4. /sc:test --coverage --e2e --pup --persona-qa
   "Tests validating improvements"

🔧 Recommended MCP Servers: --pup --seq
💡 Smart Flag Recommendations:
--monitoring (continuous performance tracking)
--benchmark (before/after comparison)
--profile (detailed profiling report)

📊 Estimated Time: 1-3 hours
🎯 Expected Improvement: 40-80% speed increase (data-dependent)
```

### Example 3: Advanced API Security (English)
```bash
User: /sc:recommend "Need to secure API with authentication and authorization"

🎯 Project Analysis: API security - Advanced level
🌍 Language: English detected
📊 Level: Expert + Security focus
🎭 Persona: --persona-security + --persona-backend

✅ SuperClaude Recommended Flow:
1. /sc:analyze --security --seq --persona-security
   "Comprehensive security analysis and threat modeling"

2. /sc:scan --security --owasp --deps --strict --persona-security
   "OWASP Top 10 vulnerability scan and dependency check"

3. /sc:design --api --ddd --seq --ultrathink --persona-architect
   "Secure API architecture with proper authentication patterns"

4. /sc:build --feature --tdd --persona-backend
   "Implement security features with test-driven development"

5. /sc:improve --security --harden --persona-security
   "Security hardening and production-ready configurations"

🔧 Recommended MCP Servers: --seq
💡 Advanced Security Options:
--token-based-auth --role-based-access --rate-limiting
--audit-logging --encryption --secure-headers

📊 Estimated Timeline: 1-2 weeks
🔒 Security Level: Enterprise-grade
```

### Example 4: React Component Development
```bash
User: /sc:recommend "I'm going to create a new user profile component"

🎯 Project Analysis: React UI component development
🌍 Language: Turkish
📊 Level: Intermediate development
🎭 Persona: --persona-frontend + --persona-qa

✅ SuperClaude Recommended Flow:
1. /sc:design --api --seq --persona-architect
   "Component interface and props design"

2. /sc:build --feature --magic --react --persona-frontend
   "Create accessible React component with Magic"

3. /sc:test --coverage --e2e --pup --persona-qa
   "E2E tests and accessibility validation"

4. /sc:analyze --code --c7 --persona-frontend
   "React best practices and optimization"

🔧 Recommended MCP Servers: --magic --c7 --pup
💡 UI/UX Recommendations:
--accessibility --responsive --design-system
--component-library --storybook-integration

📊 Estimated Time: 2-4 hours
🎨 Features: Accessible, responsive, testable component
```

## Intelligent Recommendation Format

```yaml
standard_response_format:
  header:
    - 🎯 Project analysis
    - 🌍 Language detection
    - 📊 Level determination

  main_recommendations:
    - ✅ Main recommendations (3 commands)
    - 💡 Additional recommendations (optional)
    - 🚀 Quick start (if available)

  enhanced_features:
    - 🔧 Smart flag recommendations
    - 📊 Time/Budget estimation
    - 🎯 Success metrics
    - 📚 Learning resources
```

## Step 3: Project Context Detection System

### Project Type Detection Algorithm

```yaml
project_detection:
  file_system_analysis:
    react_project:
      indicators: ["package.json with react", "src/App.jsx", "public/", "node_modules/react"]
      detection_commands:
        primary: ["/sc:build --feature --magic --react", "/sc:test --coverage --e2e --pup"]
        personas: ["--persona-frontend", "--persona-qa"]
        mcp: ["--magic", "--c7", "--pup"]

    vue_project:
      indicators: ["package.json with vue", "src/App.vue", "vue.config.js"]
      detection_commands:
        primary: ["/sc:build --feature --magic", "/sc:analyze --code --c7"]
        personas: ["--persona-frontend"]
        mcp: ["--magic", "--c7"]

    node_api_project:
      indicators: ["package.json with express", "server.js", "routes/", "controllers/"]
      detection_commands:
        primary: ["/sc:design --api --ddd --seq", "/sc:build --feature --tdd"]
        personas: ["--persona-backend", "--persona-security"]
        mcp: ["--seq", "--c7"]

    python_project:
      indicators: ["requirements.txt", "setup.py", "src/", "main.py", "Dockerfile"]
      detection_commands:
        primary: ["/sc:analyze --code --seq", "/sc:design --seq --ultrathink"]
        personas: ["--persona-analyzer", "--persona-architect"]
        mcp: ["--seq"]

    database_project:
      indicators: ["schema.sql", "migrations/", "models/", "prisma.schema"]
      detection_commands:
        primary: ["/sc:migrate --database --validate", "/sc:analyze --security --seq"]
        personas: ["--persona-backend", "--persona-security"]
        mcp: ["--seq"]

  project_size_estimation:
    small_project:
      file_count: "<50 files"
      complexity: "simple"
      recommended_approach: "direct implementation"

    medium_project:
      file_count: "50-200 files"
      complexity: "moderate"
      recommended_approach: "plan -> analyze -> implement"

    large_project:
      file_count: ">200 files"
      complexity: "complex"
      recommended_approach: "comprehensive analysis -> design -> implement"
```

### Context-Aware Examples

```bash
/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:build --feature --magic --react --persona-frontend
   "New component compatible with existing design system"

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

3. /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: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:scan --security --owasp --deps --strict --persona-security
   "OWASP Top 10 and dependency security scan"

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

3. /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)
```

## Step 4: Real-Time Streaming Mode

### Continuous Recommendation System

```yaml
streaming_mode:
  activation:
    command: "/sc:recommend --stream [project description]"
    purpose: "Continuous recommendation throughout project"

  flow_tracking:
    phase_1: Analysis & Planning
      commands: ["/sc:analyze", "/sc:design"]
      next_phase_trigger: "analysis_complete"

    phase_2: Implementation
      commands: ["/sc:build", "/sc:implement"]
      next_phase_trigger: "implementation_complete"

    phase_3: Testing & Validation
      commands: ["/sc:test", "/sc:scan"]
      next_phase_trigger: "testing_complete"

    phase_4: Deployment & Monitoring
      commands: ["/sc:deploy", "/sc:improve"]
      project_complete: true
```

### Streaming Example

```bash
/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:analyze --seq --c7 --persona-architect
   "E-commerce architecture and technology selection"

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

--- STREAM CONTINUING ---
```

## Step 5: Alternative Recommendation Engine

### Multiple Option Presentation

```yaml
alternative_engine:
  structure:
    primary_recommendation: "Most suitable option"
    alternatives: "2-3 different approaches"
    comparison_matrix: "Advantage/disadvantage analysis"
    community_preference: "Popularity rate"

  categories:
    technology_alternatives:
      frontend: ["React", "Vue", "Angular", "Svelte"]
      backend: ["Node.js", "Python", "Java", "Go"]
      database: ["PostgreSQL", "MongoDB", "MySQL", "Redis"]

    approach_alternatives:
      development: ["TDD", "BDD", "Agile", "Waterfall"]
      deployment: ["Docker", "Kubernetes", "Serverless", "Traditional"]
      testing: ["Unit", "Integration", "E2E", "Performance"]
```

### Alternative Example

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

🎯 PROJECT ANALYSIS: Blog site development

⭐ BEST RECOMMENDATION:
/sc:build --feature --magic --nextjs --persona-frontend
   "Modern, SEO-friendly blog with Next.js"

🔧 ALTERNATIVES:
1. /sc:build --feature --react --static --persona-frontend
   ✅ Advantage: Simpler learning curve
   ❌ Disadvantage: Less SEO optimization
   👥 Users: 35% prefer this

2. /sc:build --feature --vue --nuxt --persona-frontend
   ✅ Advantage: Great developer experience
   ❌ Disadvantage: Smaller community
   👥 Users: 20% prefer this

3. /sc:build --feature --gatsby --static --persona-frontend
   ✅ Advantage: Excellent performance and SEO
   ❌ Disadvantage: More complex configuration
   👥 Users: 15% prefer this

📊 COMPARISON TABLE:
| Technology | Speed | SEO | Learning | Community |
|-----------|-------|-----|----------|-----------|
| Next.js | ⚡⚡⚡ | ⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ |
| React | ⚡⚡ | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
| Vue/Nuxt | ⚡⚡⚡ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
| Gatsby | ⚡⚡⚡ | ⭐⭐⭐ | ⭐ | ⭐⭐ |

🏆 COMMUNITY PREFERENCE: Next.js (30%)
```

## Step 6: Time and Budget Estimation System

### Intelligent Estimation Algorithm

```yaml
estimation_engine:
  complexity_factors:
    project_type:
      simple_component: 1-3 days
      feature_development: 1-2 weeks
      microservice: 2-4 weeks
      full_application: 1-3 months
      enterprise_system: 3-6 months

    experience_multiplier:
      beginner: 2.0x
      intermediate: 1.5x
      expert: 1.0x
      senior: 0.8x

    scope_factors:
      small_scope: 1.0x
      medium_scope: 1.5x
      large_scope: 2.5x
      enterprise_scope: 4.0x

  time_estimates:
    ml_projects:
      data_collection: 20-30% of total time
      preprocessing: 15-25% of total time
      model_training: 10-20% of total time
      evaluation: 10-15% of total time
      deployment: 15-25% of total time

    web_projects:
      design: 15-25% of total time
      frontend: 30-40% of total time
      backend: 25-35% of total time
      testing: 10-20% of total time
      deployment: 5-15% of total time
```

### Estimation Examples

```bash
/sc:recommend "I'm developing a classification model" --estimate

🎯 PROJECT ANALYSIS: Classification model development
📊 Estimation Mode: Active

⏱️ TIME ESTIMATE:
- Total Time: 2-4 weeks
- Data Collection: 4-7 days (20%)
- Preprocessing: 3-5 days (15%)
- Model Training: 2-4 days (10%)
- Evaluation: 2-3 days (10%)
- Deployment: 3-5 days (15%)
- Buffer: 4-7 days (30%)

💰 BUDGET ESTIMATE:
- Development Time: 80-120 hours
- Experience Level: Intermediate (1.5x multiplier)
- Total Effort: 120-180 hours

🎯 CRITICAL FACTORS:
- Data quality and quantity: High impact
- Model complexity: Medium impact
- Deployment requirements: Medium impact

⚠️ RISK ASSESSMENT:
- Data cleaning difficulty: Medium risk
- Model performance: Medium risk
- Model drift: Low risk

🚀 QUICK START: MVP within 1 week
```

```bash
/sc:recommend "corporate website" --estimate

🎯 PROJECT ANALYSIS: Corporate website
📊 Estimation Mode: Active

⏱️ TIME ESTIMATE:
- Total Time: 4-8 weeks
- Design and UX: 1-2 weeks (25%)
- Frontend Development: 2-3 weeks (40%)
- Backend and CMS: 1-2 weeks (25%)
- Testing and Optimization: 0.5-1 week (10%)

💰 BUDGET ESTIMATE:
- Development Time: 160-320 hours
- Team Size: 2-3 people
- Total Project Engineering: 320-960 hours

🎯 FEATURE SCOPE:
- Homepage and services: Required
- About and contact: Required
- Blog/news: Optional (+1 week)
- Admin panel: Optional (+1-2 weeks)
- Multi-language: Optional (+1 week)

📱 DEVICE SUPPORT:
- Responsive design: Included
- Mobile app: Additional 4-8 weeks
- PWA: Additional 1-2 weeks

⚠️ PROJECT RISKS:
- Content management needs: Medium risk
- SEO requirements: Low risk
- Browser compatibility: Low risk
```

## Step 7: Smart Flag Recommendation System

### Context-Based Flag Recommendations

```yaml
smart_flag_engine:
  context_detection:
    project_size:
      small: "--quick --simple --no-validation"
      medium: "--plan --validate --profile"
      large: "--plan --validate --seq --ultrathink"

    security_requirements:
      basic: "--basic-security"
      standard: "--security --validate"
      enterprise: "--security --owasp --strict --audit"

    performance_requirements:
      low_traffic: "--basic-optimization"
      medium_traffic: "--optimize --profile"
      high_traffic: "--optimize --profile --monitoring --benchmark"

    learning_mode:
      beginner: "--tutorial --examples --step-by-step"
      intermediate: "--guided --examples"
      expert: "--advanced --no-explanations"

  intelligent_suggestions:
    based_on_history:
      if_previous_errors: "--validate --dry-run --backup"
      if_security_issues: "--security --scan --strict"
      if_performance_issues: "--profile --optimize --monitor"
      if_large_refactor: "--plan --backup --validate"

    based_on_project_type:
      ml_project: "--data-validation --model-monitoring"
      api_project: "--security --rate-limiting --monitoring"
      frontend_project: "--accessibility --responsive --performance"
      mobile_project: "--offline --sync --battery-optimized"
```

### Smart Flag Examples

```bash
/sc:recommend "performance improvement"

🎯 PROJECT ANALYSIS: Performance optimization
🧠 SMART FLAG RECOMMENDATIONS:

📊 BASED ON HISTORY:
- Previous errors encountered: --validate --backup
- Previous security issues: --security --scan
- Large refactoring history: --plan --dry-run

🎯 PROJECT CONTEXT:
- Large project (>200 files): --seq --ultrathink
- Production environment: --validate --monitoring
- High traffic: --benchmark --profile

💡 RECOMMENDED COMMAND:
/sc:improve --performance --optimize --profile --monitoring --validate

🔧 ADDITIONAL FLAG OPTIONS:
--memory-optimization (if RAM usage is high)
--database-optimization (if DB is slow)
--cdn-integration (if static resources are many)
```

```bash
/sc:recommend "my first React component"

🎯 PROJECT ANALYSIS: React component development - Beginner
🧠 SMART FLAG RECOMMENDATIONS:

📚 LEARNING MODE:
- Beginner detected: --tutorial --examples --step-by-step
- Component development: --magic --design-system

🎯 PROJECT CONTEXT:
- React project: --component-library --storybook
- Accessibility required: --a11y --wcag

💡 RECOMMENDED COMMAND:
/sc:build --feature --magic --react --tutorial --examples --persona-frontend

🔧 ADDITIONAL LEARNING FLAGS:
--guided-development (step-by-step guidance)
--best-practices (React best practices)
--error-handling (error handling examples)
```

## Step 8: Community Patterns and Final Integration

### Community Data-Based Recommendations

```yaml
community_patterns:
  successful_workflows:
    web_development:
      most_successful_flow:
        - "/sc:analyze --code --c7"
        - "/sc:design --api --seq"
        - "/sc:build --feature --magic --tdd"
        - "/sc:test --coverage --e2e --pup"
      success_rate: "87%"
      user_feedback: "Highly recommended for React projects"

    ml_development:
      most_successful_flow:
        - "/sc:analyze --seq --c7 --persona-mentor"
        - "/sc:design --seq --ultrathink --persona-architect"
        - "/sc:build --feature --tdd --persona-frontend"
        - "/sc:improve --performance --iterate"
      success_rate: "82%"
      user_feedback: "Great for ML beginners"

  popular_command_combinations:
    security_focused:
      - "/sc:scan --security --owasp"
      - "/sc:analyze --security --seq"
      - "/sc:improve --security --harden"
      usage_frequency: "45% of production projects"

    performance_optimization:
      - "/sc:analyze --performance --pup --profile"
      - "/sc:improve --performance --iterate"
      - "/sc:test --coverage --benchmark"
      usage_frequency: "38% of optimization projects"

  user_preferences:
    technology_stacks:
      react_stack: "65% of web projects"
      nextjs_stack: "42% of production sites"
      python_ml: "78% of ML projects"
      nodejs_api: "71% of backend projects"

    development_approaches:
      tdd_approach: "58% prefer TDD"
      iterative_approach: "73% prefer iterative development"
      security_first: "67% prioritize security early"
```

### Final Command Integration

```yaml
recommend_command_implementation:
  command_structure: "/sc:recommend [query] --options [flags]"

  available_options:
    --estimate: "Includes time and budget estimation"
    --alternatives: "Provides multiple solution recommendations"
    --stream: "Continuous project tracking mode"
    --community: "Includes community data"
    --language [tr|en|auto]: "Language setting"
    --expertise [beginner|intermediate|expert]: "Level setting"

  response_format:
    analysis_section:
      - 🎯 Project analysis
      - 🌍 Language detection
      - 📊 Level determination
      - 🎭 Persona recommendation
      - 📁 Project context

    recommendations_section:
      - ✅ Main recommendations (3 commands)
      - 💡 Additional recommendations (optional)
      - 🔧 Smart flag recommendations
      - 🚀 Quick start options

    enhanced_section:
      - ⏱️ Time/budget estimation (with --estimate)
      - 🔧 Alternative options (with --alternatives)
      - 👥 Community data (with --community)
      - 🔄 Continuous flow (with --stream)
```

### Comprehensive Final Example

```bash
/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:design --api --ddd --seq --ultrathink --persona-architect
   "E-commerce domain architecture and system design"

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

3. 🔒 SECURITY AND BACKEND
   /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:analyze → /sc:design → /sc:build → /sc:test → /sc:deploy
Success Rate: 87% (from 2,847 projects)

📈 Popular Features...

© SuperClaude-Org · MIT · SuperClaude-Org/SuperClaude_Framework

Similar slash commands

All slash commands for Agent setup: memory, context, orchestration →

recommend by other authors comes first.

recommend 0xSteph recommend turns a freeform pentest task into a routing decision: names one or two specialist agents and lists the next commands. Useful when you know the goal but not which agent to pick. CX Codex +1 ★ 2,482repo stars recsys-pipeline-architect Seth Hobson recsys-pipeline-architect designs six-stage recommendation, ranking, and feed pipelines. Use it when a system must choose the top K items for a user and context. CX Codex +1 4,200installs academic-letter-architect lyndonkl academic-letter-architect — a skill for writing academic recommendation letters with specific examples, comparative statements, and calibrated enthusiasm. CX Codex +1 128installs ux-recommend Laith Aljunaidy Redirects calls to /ux-discover --recommend. It acts as a temporary alias until version 4.1 for running UX recommendations. CX Codex +1 ★ 110repo stars nano-banana-pro-prompts-recommend-skill YouMind-OpenLab nano-banana-pro-prompts-recommend-skill is a Claude Code skill that finds image generation prompts in a library of 10,000+ texts. Prompts for Nano Banana Pro also work with DALL-E, Midjourney, Stable Diffusion, and Flux. CX Codex +1 1installs connect-recommend official Stripe The connect-recommend skill reads your business from a URL or description and recommends a Stripe Connect configuration with a matching charge pattern. Useful when you're building a marketplace or platform that pays out sellers. CX Codex GP ChatGPT +1 ★ 8,052repo stars moodtrip-hotel-search adiny moodtrip-hotel-search is a Claude Code skill for searching MoodTrip.ai hotels, comparing prices and reviews, and getting a booking link. You complete the reservation on MoodTrip. CX Codex +1 7installs

From the same set56

The whole set →
socratic-mentor The socratic-mentor subagent teaches programming concepts through guided questions. Use it to examine code, work through Clean Code principles, or identify GoF patterns. CX Codex ★ 23,950repo stars spec-panel spec-panel assembles a virtual panel of recognized software engineers to review and improve technical specifications inside Claude Code. CX Codex +1 ★ 23,950repo stars pm The pm command launches automatically at session start and coordinates all sub-agents while preserving project context via Serena MCP memory. No manual invocation needed—it runs in the background. CX Codex +1 ★ 23,950repo stars pm-agent pm-agent — a subagent that restores the last session's context from Serena MCP memory and files lessons and mistakes under docs/ while you work. CX Codex ★ 23,950repo stars troubleshoot troubleshoot stops agents from blindly retrying failed commands and enforces systematic root cause analysis on errors. CX Codex +1 ★ 23,950repo stars token-efficiency token-efficiency switches the agent into a compressed output mode: bullets, tables, abbreviations. Useful when context runs low or the task is large. CX Codex +1 ★ 23,950repo stars pm pm tracks work through Plan-Do-Check-Act, scores confidence before implementation, and restores context from your last session at startup. CX Codex +1 ★ 23,950repo stars deep-research deep-research activates systematic research mode to investigate topics, verify facts, and produce structured reports with citations. CX Codex +1 ★ 23,950repo stars

Project sponsors

Companies that keep this analytics open