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
.claude/commands/recommend.mdWhat 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.mdCall it with /recommend. For all projects use ~/.claude/commands/
Manually: put the files in place
~/.codex/prompts/recommend.mdCall it with /prompts:recommend. Codex marks this format deprecated in favour of skills
Manually: put the files in place
.github/prompts/recommend.prompt.mdManually: put the files in place
.gemini/commands/recommend.tomlGemini stores commands as TOML: the prompt text goes into the prompt field
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.