🚀 Guide to Optimal Settings for Each SuperClaude Development Task

1. Feature Implementation

add a simple feature

/implement "feature description" --persona-frontend --c7 --validate
- Use: UI components, simple CRUD
- Benefits: pattern reference with Context7, validation included

implementing complex features

/implement "feature description" --think-hard --seq --wave-mode auto --validate
- Use: Multi-module integration, API integration
- Pros: systematic analysis, step-by-step implementation, automatic wave mode

rails backend features

/implement "API features" --persona-backend --seq --delegate auto
- Use: Service objects, complex business logic
- Pros: Rails pattern conformance, parallelization

2. Enhancement

optimize performance

/improve --perf --persona-performance --think --validate
- Use: N+1 queries, caching, speedup
- Benefits: Measurement-based optimization

improve code quality

/improve --quality --persona-refactor --loop --iterations 3
- Use for: refactoring, resolving technical debt
- Pros: Iterative improvements, incremental improvements

large-scale refactoring

/improve --wave-mode force --wave-strategy systematic --validate
- Use: Improve overall architecture
- Pros: systematic approach, step-by-step validation

3. Bug Fixing (Bug Fixing)

simple bug fixing

/troubleshoot "error symptoms" --persona-analyzer --seq
- Use: clear error, single cause
- Pros: Quick cause analysis

complex debugging

/analyze --think-hard --seq --persona-analyzer --introspect
- Use: Multi-cause, system-wide issues
- Pros: Deep analysis, transparent thought process

fixing security vulnerabilities

/analyze --focus security --persona-security --ultrathink --validate
- Use: Security issues, certification/authorization issues
- Pros: Thorough security review

4. Rails-specific tasks

model/Migration

/implement "implement model" --delegate files --c7
# or utilize the MCP agent
mcp__models__task "Implement models"

controller/Routing

/build --api --persona-backend --validate
# or utilize the MCP agent
mcp__controllers__task "Implement controllers"

views/Frontend

/implement "UI Component" --persona-frontend --magic --c7
# or utilize the MCP agent
mcp__views__task "Implement Views"

stimulus controller

/implement "Stimulus feature" --persona-frontend --seq
# or utilize the MCP agent
mcp__stimulus__task "Implement Stimulus controller"

5. Set up efficiency optimizations

enable token saving mode

/implement "feature" --uc --answer-only
- Use: Simple tasks, clear requirements
- Benefits: 30-50% token savings

parallel processing mode

/analyze --delegate auto --concurrency 7
- Use: Analyzing large codebases
- Benefits: Faster processing time

iterative improvement mode

/improve --loop --iterations 5 --interactive
- Use: Incremental quality improvement
- Pros: Allows step-by-step review

6. Example integrated workflow

full Feature Development Cycle

# 1. analyze and plan
/analyze "requirements" --think-hard --seq

# 2. implement
/implement "feature" --wave-mode auto --validate

# 3. Test
/test e2e --persona-qa --play

# 4. optimize
/improve --perf --loop --iterations 3

implement the Rails API endpoint

# 1. design your model
mcp__models__task "User model with associations"

# 2. Implement controllers
mcp__controllers__task "API controllers with JWT auth"

# 3. Service logic
/implement "UserService" --persona-backend --seq

# 4. Write tests
mcp__tests__task "Write RSpec tests"

7. recommended flag combinations

🏆 Best practice combinations

rapid development
--persona-[domain] --c7 --uc

stable development
--validate --think --seq

large scale operations
--wave-mode auto --delegate auto --validate

quality-driven
--loop --iterations 3 --persona-refactor --validate

8. Task-specific checklists

✅ When implementing a feature

- Choose the right persona
- Reference the pattern with Context7
- Validate with validate
- Consider wave-mode based on complexity

✅ When fixing bugs

- Utilize analyzer persona
- Analyze systematically with Sequential
- Verify thought processes with introspect
- Confirm root cause resolution

✅ When improving performance

- utilize performance persona
- Take a measurement-based approach
- Iteratively improve with LOOP
- Validate improvements with VALIDATE

💡 Pro Tips

1. judge complexity: modify 3 or more files → add --delegate
2. work with Rails: prioritize MCP agents (models, controllers, views)
3. quality assurance: always add --validate
4. token management: add --uc for long tasks
5. Iterations: -utilize -loop for incremental improvements

by utilizing these settings, you can take full advantage of SuperClaude's powerful features for efficient development!