External/SuperClaude
1
0
Fork 0
mirror of https://github.com/SuperClaude-Org/SuperClaude_Framework.git synced 2025-12-17 17:56:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

docs: Transform documentation to emphasize simplicity and auto-activation

Browse Source 
Update all Docs/ guides to lead with "just start using it" approach while
keeping comprehensive information available. Key changes:

- Add prominent "Simple Truth" and "Just Start Here" sections
- Emphasize intelligent routing and auto-activation throughout
- Reframe detailed guides as optional curiosity rather than required study
- Use casual, humble developer tone with emojis for clarity
- Transform "learn first" to "discover through use" messaging
- Make auto-expert selection and flag activation prominent
- Remove any marketing language in favor of honest, straightforward content

Files updated: superclaude-user-guide.md, commands-guide.md, flags-guide.md,
personas-guide.md, installation-guide.md

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
NomenAK 2025-07-14 16:51:40 +02:00
parent 3bd577672a
commit f97f48244c
5 changed files with 349 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
Docs/commands-guide.md
View File

@ -1,36 +1,71 @@
# SuperClaude Commands Guide 🛠️ # SuperClaude Commands Guide 🛠️
## 💡 Don't Overthink It - SuperClaude Picks the Right Tools
**The truth about these 15 commands**: You don't need to memorize them. Just start with `/analyze` or `/build` and let SuperClaude figure out the rest!
**Here's how it actually works:**
- Type `/` in Claude Code → See available commands
- Use basic ones like `/analyze`, `/build`, `/improve`
- **SuperClaude automatically picks the best tools and experts** for each situation
- More commands become useful as you get comfortable
**Auto-activation is the secret sauce** 🪄 - SuperClaude detects what you're trying to do and activates the right specialists (security expert, performance optimizer, etc.) without you managing any of it.
---
## Quick "Just Try These" List 🚀
**Start here** (no reading required):
```bash
/help # See what's available
/analyze src/ # Smart analysis of your code
/build # Intelligent project building
/improve messy-file.js # Clean up code automatically
/troubleshoot "error" # Get help with problems
```
**That's honestly enough to get started.** Everything else below is here when you get curious about what other tools are available.
---
A practical guide to all 15 SuperClaude slash commands. We'll be honest about what works well and what's still rough around the edges. A practical guide to all 15 SuperClaude slash commands. We'll be honest about what works well and what's still rough around the edges.
## Quick Reference 📋 ## Quick Reference 📋
| Command | Purpose | Best For | *(You really don't need to memorize this - just pick what sounds useful)*
|---------|---------|----------|
| `/analyze` | Code analysis | Finding issues, understanding codebases | | Command | Purpose | Auto-Activates | Best For |
| `/build` | Project building | Compilation, bundling, deployment prep | |---------|---------|-----------------|----------|
| `/cleanup` | Technical debt | Removing dead code, organizing files | | `/analyze` | Smart code analysis | Security/performance experts | Finding issues, understanding codebases |
| `/design` | System design | Architecture planning, API design | | `/build` | Intelligent building | Frontend/backend specialists | Compilation, bundling, deployment prep |
| `/document` | Documentation | README files, code comments, guides | | `/improve` | Automatic code cleanup | Quality experts | Refactoring, optimization, quality fixes |
| `/estimate` | Project estimation | Time/effort planning, complexity analysis | | `/troubleshoot` | Problem investigation | Debug specialists | Debugging, issue investigation |
| `/explain` | Educational help | Learning concepts, understanding code | | `/test` | Smart testing | QA experts | Running tests, coverage analysis |
| `/git` | Git operations | Smart commits, branch management | | `/document` | Auto documentation | Writing specialists | README files, code comments, guides |
| `/improve` | Code enhancement | Refactoring, optimization, quality fixes | | `/git` | Enhanced git workflows | DevOps specialists | Smart commits, branch management |
| `/index` | Command help | Finding the right command for your task | | `/design` | System design help | Architecture experts | Architecture planning, API design |
| `/load` | Context loading | Project analysis, codebase understanding | | `/explain` | Learning assistant | Teaching specialists | Learning concepts, understanding code |
| `/spawn` | Complex orchestration | Multi-step operations, workflow automation | | `/cleanup` | Debt reduction | Refactoring experts | Removing dead code, organizing files |
| `/task` | Project management | Long-term feature planning, task tracking | | `/scan` | Security/quality scans | Security experts | Vulnerability detection, compliance |
| `/test` | Testing | Running tests, coverage analysis | | `/load` | Context understanding | Analysis experts | Project analysis, codebase understanding |
| `/troubleshoot` | Problem solving | Debugging, issue investigation | | `/estimate` | Smart estimation | Planning experts | Time/effort planning, complexity analysis |
| `/spawn` | Complex workflows | Orchestration system | Multi-step operations, workflow automation |
| `/task` | Project management | Planning system | Long-term feature planning, task tracking |
**Pro tip**: Just try the ones that sound useful. SuperClaude will automatically activate the right experts and tools for each situation! 🎯
## Development Commands 🔨 ## Development Commands 🔨
### `/build` - Project Building ### `/build` - Project Building
**What it does**: Builds, compiles, and packages projects with smart error handling. **What it does**: Builds, compiles, and packages projects with smart error handling.
**The easy way**: Just type `/build` and SuperClaude figures out your build system automatically! 🎯
**When to use it**: **When to use it**:
- You need to compile/bundle your project - You need to compile/bundle your project (just try `/build`)
- Build process is failing and you want help debugging - Build process is failing and you want help debugging
- Setting up build optimization - Setting up build optimization (it auto-detects what you need)
- Preparing for deployment - Preparing for deployment
**Basic syntax**: **Basic syntax**:
@ -97,14 +132,16 @@ A practical guide to all 15 SuperClaude slash commands. We'll be honest about wh
## Analysis Commands 🔍 ## Analysis Commands 🔍
### `/analyze` - Code Analysis ### `/analyze` - Code Analysis
**What it does**: Comprehensive analysis of code quality, security, performance, and architecture. **What it does**: Comprehensive analysis of code quality, security, performance, and architecture.
**The magic**: SuperClaude automatically detects what kind of analysis you need and activates the right experts! 🔍
**When to use it**: **When to use it**:
- Understanding unfamiliar codebases - Understanding unfamiliar codebases (just point it at any folder)
- Finding security vulnerabilities - Finding security vulnerabilities (security expert auto-activates)
- Performance bottleneck hunting - Performance bottleneck hunting (performance expert jumps in)
- Code quality assessment - Code quality assessment (quality specialist takes over)
**Basic syntax**: **Basic syntax**:
```bash ```bash
@ -634,24 +671,30 @@ A practical guide to all 15 SuperClaude slash commands. We'll be honest about wh
## Final Notes 📝 ## Final Notes 📝
**Remember:** **The real truth about these commands** 💯:
- Commands work best when you're specific about what you want - **Just try them** - You don't need to study this guide first
- Use `--preview` and `--safe` flags liberally - **Start with the basics** - `/analyze`, `/build`, `/improve` cover most needs
- Start small (single files) before running on entire projects - **Let auto-activation work** - SuperClaude picks the right experts automatically
- These commands enhance your workflow, they don't replace understanding your tools - **Experiment freely** - Use `--preview` if you want to see what would happen first
**Still rough around the edges:** **Still rough around the edges:**
- Complex orchestration (spawn, task) may not work perfectly - Complex orchestration (spawn, task) may not work perfectly
- Some analysis depends heavily on your project setup - Some analysis depends heavily on your project setup
- Error handling could be better in some commands - Error handling could be better in some commands
**Getting better all the time:** **Getting better all the time:**
- We actively improve commands based on user feedback - We actively improve commands based on user feedback
- Newer commands (analyze, improve) tend to work better - Newer commands (analyze, improve) tend to work better
- Documentation and examples are constantly being updated - Auto-activation keeps getting smarter
**Don't stress about memorizing this** 🧘‍♂️
- SuperClaude is designed to be discoverable through use
- Type `/` to see available commands
- Commands suggest what they can do when you use `--help`
- The intelligent routing handles most of the complexity
**Need help?** Check the GitHub issues or create a new one if you're stuck! 🚀 **Need help?** Check the GitHub issues or create a new one if you're stuck! 🚀
--- ---
*Happy coding! We hope these commands make your development workflow a bit smoother. 🙂* *Happy coding! Just remember - you can skip most of this guide and learn by doing. 🎯*

114
Docs/flags-guide.md
View File

@ -1,28 +1,63 @@
# SuperClaude Flags User Guide 🏁 # SuperClaude Flags User Guide 🏁
## 🤖 Most Flags Activate Automatically - Don't Stress About It!
**The honest truth**: You don't need to memorize these flags. SuperClaude automatically adds the right ones based on what you're doing!
**Here's what actually happens:**
- You type `/analyze auth.js`
- SuperClaude detects it's security-related code
- **Automatically adds** `--persona-security`, `--focus security`, `--validate`
- You get expert security analysis without managing any flags
**When might you manually use flags?**
- You want to **override** what SuperClaude picked (rare)
- You're **curious** about specific aspects (`--focus performance`)
- You want to **experiment** with different approaches
**Bottom line**: Just use basic commands and let the auto-activation work. These flags are here when you want them, not because you need them. 🎯
---
## 🚀 Just Try These (No Flag Knowledge Required)
```bash
# These work great with zero flag knowledge:
/analyze src/ # Auto-picks the right analysis flags
/build # Auto-optimizes based on your project
/improve messy-code.js # Auto-activates quality and safety flags
/troubleshoot "weird error" # Auto-activates debugging and analysis flags
```
**See? No flags needed.** Everything below is for when you get curious about what's happening behind the scenes.
---
A practical guide to SuperClaude's flag system. Flags are like command-line options that change how SuperClaude behaves - think of them as superpowers for your commands. A practical guide to SuperClaude's flag system. Flags are like command-line options that change how SuperClaude behaves - think of them as superpowers for your commands.
## What Are Flags? 🤔 ## What Are Flags? 🤔
**Flags are modifiers** that change how SuperClaude processes your requests. They come after commands and start with `--`. **Flags are modifiers** that change how SuperClaude processes your requests. They come after commands and start with `--`.
**Basic syntax**: **Basic syntax** (but you usually don't need to know this):
```bash ```bash
/command --flag-name /command --flag-name
/command --flag-name value /command --flag-name value
/analyze src/ --focus security --depth deep /analyze src/ --focus security --depth deep
``` ```
**Two ways flags work**: **How flags actually work in practice**:
1. **Manual** - You add them explicitly: `/analyze --think --focus security` 1. **Auto-activation** - SuperClaude adds them based on context (this is the main way! 🎯)
2. **Auto-activation** - SuperClaude adds them based on context (this happens a lot!) 2. **Manual override** - You can add them explicitly if you want different behavior
**Why use flags?** **Why flags exist** (mostly automatic benefits):
- Get better, more focused results - Get better, more focused results
- Control SuperClaude's thinking depth - Auto-enable the right thinking depth
- Enable special capabilities (MCP servers) - Connect to special capabilities when useful
- Optimize for speed or detail - Optimize for speed or detail based on your task
- Direct attention to specific areas - Direct attention to what you're actually working on
**The key point**: SuperClaude handles flag selection intelligently so you don't have to think about it! 🧠
## Flag Categories 📂 ## Flag Categories 📂
@ -457,19 +492,19 @@ SuperClaude automatically adds flags based on context. Here's when:
## Tips for Effective Flag Usage 💡 ## Tips for Effective Flag Usage 💡
### Starting Out ### Starting Out (The Honest Truth)
1. **Begin simple**: Try basic flags like `--think` and `--focus` 1. **Just ignore flags at first** - Auto-activation handles 90% of cases perfectly
2. **Watch auto-activation**: See what SuperClaude adds automatically 2. **Watch what gets auto-activated** - You'll learn by seeing what SuperClaude picks
3. **Use `--help`**: Many commands show available flags 3. **Use `--help` when curious** - Many commands show what flags are available
4. **Start safe**: Use `--safe-mode` and `--validate` for important work 4. **Trust the automation** - SuperClaude usually picks better than manual selection
### Getting Advanced ### Getting Advanced (If You Want To)
1. **Learn combinations**: `--think --seq --c7` works great together 1. **Experiment with overrides** - Try `--persona-security` on non-security code for different perspectives
2. **Understand auto-activation**: Know when flags get added automatically 2. **Learn the useful combos** - `--safe-mode --validate` for important stuff
3. **Use personas**: They're like having specialists on your team 3. **Understand the performance trade-offs** - Fast (`--uc --no-mcp`) vs thorough (`--think-hard --all-mcp`)
4. **Optimize for your workflow**: Fast (`--uc --no-mcp`) vs thorough (`--think-hard --all-mcp`) 4. **Use flags for learning** - `--verbose` when you want to understand what's happening
### Performance Tips ### Performance Tips (For Power Users)
- **For speed**: `--uc --no-mcp --scope file` - **For speed**: `--uc --no-mcp --scope file`
- **For thoroughness**: `--think-hard --all-mcp --delegate auto` - **For thoroughness**: `--think-hard --all-mcp --delegate auto`
- **For safety**: `--safe-mode --validate --preview` - **For safety**: `--safe-mode --validate --preview`
@ -479,25 +514,30 @@ SuperClaude automatically adds flags based on context. Here's when:
## Final Notes 📝 ## Final Notes 📝
**Remember:** **The real truth about flags** 💯:
- Flags make SuperClaude more powerful but also more complex - **Auto-activation is usually better** than manual flag selection
- Start simple and add flags as you learn what they do - **You can ignore most of this guide** and just use basic commands
- Auto-activation usually gets it right - trust it until you know better - **Flags are here when you want them** - not because you need them
- `--safe-mode` and `--validate` are your friends for important work - **Learning emerges naturally** through use, not through studying
**Still evolving:** **Don't feel overwhelmed** 🧘‍♂️:
- Some advanced flags (wave, delegation) are still experimental - SuperClaude is designed to work great without flag knowledge
- Auto-activation keeps getting smarter - The detailed info above is for curiosity, not necessity
- New flags and capabilities are added regularly - Auto-activation keeps getting smarter based on usage patterns
- You're not missing out by not memorizing flags
**When in doubt:** **When you actually need flags**:
- Start with basic commands and see what auto-activates - Overriding auto-activation (rare)
- Use `--safe-mode` for anything important - Experimenting with different approaches (fun)
- Check the commands guide for flag suggestions per command - Optimizing for specific performance needs (advanced)
- GitHub issues are great for flag-related questions - Learning about what happened (educational)
**Happy flagging!** 🚩 These flags can really supercharge your SuperClaude experience once you get the hang of them. **Start simple, stay simple** 🎯:
- Use basic commands: `/analyze`, `/build`, `/improve`
- Let auto-activation handle the complexity
- Add manual flags only when you want to experiment
- Trust that SuperClaude knows what it's doing
--- ---
*Flags are like spices - a little goes a long way, and the right combination can make everything better! 🌶️* *Remember: Behind all this apparent complexity, SuperClaude is actually simple to use. Just start typing commands! 🚀*

47
Docs/installation-guide.md
View File

@ -1,6 +1,21 @@
# SuperClaude Installation Guide 📦 # SuperClaude Installation Guide 📦
A comprehensive guide to installing SuperClaude v3. We'll be honest - this might seem a bit complex at first, but we've tried to make it as straightforward as possible. ## 🎯 It's Easier Than It Looks!
**The honest truth**: This guide looks long because we want to cover all the details, but installation is actually pretty simple. Most people are done in 2 minutes with one command!
**TL;DR for the impatient:**
```bash
git clone <repository-url> && cd SuperClaude
python3 SuperClaude.py install --quick
# That's it! 🎉
```
**What just happened?** SuperClaude set up everything you need automatically. No complex configuration, no dependency hunting, no setup headaches.
---
A comprehensive guide to installing SuperClaude v3. But remember - most people never need to read past the quick start above! 😊
## Before You Start 🔍 ## Before You Start 🔍
@ -35,22 +50,28 @@ If any of these fail, see the [Prerequisites Setup](#prerequisites-setup-🛠️
## Quick Start 🚀 ## Quick Start 🚀
**TL;DR for the impatient:** **🏆 The "Just Get It Working" Approach (Recommended for 90% of Users)**
```bash ```bash
# Clone the repo # Clone the repo
git clone <repository-url> git clone <repository-url>
cd SuperClaude cd SuperClaude
# Install with recommended settings # Install with recommended settings
python3 SuperClaude.py install --quick python3 SuperClaude.py install --quick
# That's it! 🎉 # That's it! 🎉
``` ```
This installs SuperClaude with the most commonly used features. Takes about 2 minutes and uses ~50MB of disk space. **What you just got:**
- ✅ All 15 smart commands that auto-activate experts
- ✅ 11 specialist personas that know when to help
- ✅ Intelligent routing that figures out complexity for you
- ✅ About 2 minutes of your time and ~50MB disk space
**Want to see what would happen first?** **Seriously, you're done.** Open Claude Code, type `/help`, and watch SuperClaude work its magic.
**Nervous about what it will do?** See first with:
```bash ```bash
python3 SuperClaude.py install --quick --dry-run python3 SuperClaude.py install --quick --dry-run
``` ```
@ -439,15 +460,17 @@ python3 SuperClaude.py install --profile developer --dev-hooks
## What's Next? 🚀 ## What's Next? 🚀
**Now that SuperClaude is installed:** **Now that SuperClaude is installed (that was easy, right?):**
1. **Try the basic commands** - Start with `/help` and `/analyze` 1. **Just start using it** - Try `/analyze some-file.js` or `/build` and see what happens ✨
2. **Read the user guides** - Check `Docs/` for more detailed guides 2. **Don't stress about learning** - SuperClaude figures out what you need automatically
3. **Experiment** - SuperClaude is designed to enhance your existing workflow 3. **Experiment freely** - Commands like `/improve` and `/troubleshoot` are pretty forgiving
4. **Give feedback** - Let us know what works and what doesn't 4. **Read guides if curious** - Check `Docs/` when you want to understand what just happened
5. **Stay updated** - Check for updates occasionally 5. **Give feedback** - Let us know what works and what doesn't
**Remember:** SuperClaude is designed to make Claude Code more useful, not to replace your existing tools. Start small and gradually use more features as you get comfortable. **The real secret**: SuperClaude is designed to enhance your existing workflow without you having to learn a bunch of new stuff. Just use it like you'd use regular Claude Code, but notice how much smarter it gets! 🎯
**Still feeling uncertain?** Start with just `/help` and `/analyze README.md` - you'll see how non-intimidating it actually is.
--- ---

123
Docs/personas-guide.md
View File

@ -1,23 +1,55 @@
# SuperClaude Personas User Guide 🎭 # SuperClaude Personas User Guide 🎭
## 🎭 Personas Auto-Activate - No Need to Choose!
**The simple truth**: You don't need to pick personas or memorize what they do. SuperClaude automatically brings in the right expert for each situation!
**Here's what actually happens:**
- You type `/analyze auth.js` → Security expert automatically jumps in 🛡️
- You work on React components → Frontend specialist takes over 🎨
- You debug performance issues → Performance optimizer activates ⚡
- You write documentation → Professional writer helps out ✍️
**It's like having a smart team** that knows when to jump in and help, without you managing who does what.
**Manual control available** when you want it (like asking specifically for a security review of frontend code), but most of the time you can just... let it work. 🪄
---
## 🚀 Just Try These (No Persona Knowledge Required)
```bash
# These automatically activate the right experts:
/analyze payment-system/ # → Security + backend experts auto-activate
/build react-app/ # → Frontend specialist takes over
/improve slow-queries.sql # → Performance optimizer jumps in
/troubleshoot "auth failing" # → Debug specialist + security expert coordinate
```
**See the pattern?** You focus on what you want to do, SuperClaude figures out who should help. Everything below is for when you get curious about who's on the team.
---
Think of SuperClaude personas as having a team of specialists on demand. Each persona brings different expertise, priorities, and perspectives to help you with specific types of work. Think of SuperClaude personas as having a team of specialists on demand. Each persona brings different expertise, priorities, and perspectives to help you with specific types of work.
## What Are Personas? 🤔 ## What Are Personas? 🤔
**Personas are AI specialists** that change how SuperClaude approaches your requests. Instead of one generic assistant, you get access to 11 different experts who think and work differently. **Personas are AI specialists** that automatically adapt SuperClaude's behavior for different types of work. Instead of generic responses, you get expert-level help from the right specialist.
**How they work:** **How they actually work in practice:**
- **Auto-activation** - SuperClaude picks the right persona based on your request - **Auto-activation** - SuperClaude automatically picks the right expert (90% of the time this is all you need!)
- **Manual control** - You can explicitly choose with `--persona-name` flags - **Smart detection** - Recognizes security work, frontend tasks, performance issues, etc.
- **Different priorities** - Each persona values different things (security vs speed, etc.) - **Seamless switching** - Different experts jump in as needed within the same conversation
- **Specialized knowledge** - Each has deep expertise in their domain - **Team coordination** - Multiple experts collaborate automatically on complex tasks
- **Cross-collaboration** - Personas can work together on complex tasks - **Manual override available** - You can explicitly choose with `--persona-name` flags when you want a different perspective
**Why use personas?** **Why this matters (automatically):**
- Get expert-level advice for specific domains - Get expert-level advice without knowing which expert to ask
- Better decision-making aligned with your goals - Better decision-making aligned with what you're actually working on
- More focused and relevant responses - More focused and relevant responses based on the task
- Access to specialized workflows and best practices - Access to specialized workflows that activate when useful
**The magic**: You just work on your stuff, and the right experts show up when needed. 🎯
## The SuperClaude Team 👥 ## The SuperClaude Team 👥
@ -788,47 +820,52 @@ Personas often work together automatically. Here are common collaboration patter
## Tips for Effective Persona Usage 💡 ## Tips for Effective Persona Usage 💡
### Getting Started ### Getting Started (The Honest Way)
1. **Let auto-activation work** - It's usually right 1. **Just ignore personas completely at first** - Auto-activation handles everything
2. **Try manual activation** - Experiment with `--persona-*` flags 2. **Use basic commands normally** - `/analyze`, `/build`, `/improve` work great without persona knowledge
3. **Watch the differences** - See how different personas approach the same problem 3. **Notice what happens** - You'll see different types of expertise emerge naturally
4. **Use appropriate commands** - Some personas work better with specific commands 4. **Trust the automation** - SuperClaude usually picks better experts than manual selection
### Getting Advanced ### Getting Advanced (If You Want To)
1. **Learn persona priorities** - Understand what each values most 1. **Experiment with manual override** - Try `--persona-security` on frontend code for different perspectives
2. **Use persona combinations** - Different perspectives on complex problems 2. **Learn the team members** - Read about individual personas when you get curious
3. **Override when needed** - Don't be afraid to choose different personas 3. **Watch persona combinations** - See how multiple experts collaborate on complex problems
4. **Match personas to phases** - Use different personas for different project phases 4. **Use for learning** - Ask different personas the same question to see different approaches
### Best Practices ### Best Practices (Keep It Simple)
- **Match persona to problem type** - Security persona for security issues - **Let auto-activation work first** - Override only when you want different perspectives
- **Consider project phase** - Architect for planning, QA for testing - **Don't overthink it** - The right experts show up when needed
- **Use multiple perspectives** - Complex problems benefit from multiple viewpoints - **Use for experimentation** - Try different personas on the same problem for learning
- **Trust auto-activation** - It learns from patterns and usually gets it right - **Trust the intelligence** - Auto-activation learns from patterns and keeps getting better
--- ---
## Final Notes 📝 ## Final Notes 📝
**Remember:** **The real truth about personas** 💯:
- Personas are like having specialists on your team - **Auto-activation is usually better** than trying to pick the right expert yourself
- Auto-activation works well, but manual control gives you flexibility - **You can completely ignore this guide** and still get expert help automatically
- Different personas have different priorities and perspectives - **Personas exist to help you** - not to create complexity you need to manage
- Complex problems often benefit from multiple personas - **Learning happens naturally** through use, not through studying persona descriptions
**Still evolving:** **Don't feel overwhelmed by the team** 🧘‍♂️:
- Persona auto-activation is getting smarter over time - You don't need to know what each persona does
- Collaboration patterns between personas are improving - SuperClaude handles expert selection intelligently
- New specialized knowledge is being added regularly - The detailed descriptions above are for curiosity, not necessity
- You're not missing anything by letting auto-activation work
**When in doubt:** **When you might manually choose personas**:
- Let auto-activation do its thing first - **Curiosity** - "What would a security expert think about this frontend code?"
- Try the mentor persona for learning and understanding - **Learning** - "How would different experts approach this problem?"
- Use specific personas when you know what expertise you need - **Experimentation** - "Let me see this through a performance lens"
- Experiment with different personas on the same problem - **Override** - "I want architectural advice on this small utility function"
**Happy persona-ing!** 🎭 Having specialists available makes development so much more effective when you know how to work with them. **Keep it simple** 🎯:
- Use normal commands like `/analyze some-code/`
- Let the right experts automatically show up
- Manual persona control is available when you want it, not because you need it
- Focus on your work, not on managing who helps you
--- ---
*It's like having a whole development team in your pocket - just way less coffee consumption! ☕* *Behind all this apparent complexity of having 11 specialists, SuperClaude is actually simple to use. Just start coding and let the experts show up automatically! 🚀*

104
Docs/superclaude-user-guide.md
View File

@ -1,6 +1,28 @@
# SuperClaude User Guide 🚀 # SuperClaude User Guide 🚀
A comprehensive guide to understanding and using SuperClaude v3.0 effectively. This is your starting point for getting the most out of the framework. ## 🎯 The Simple Truth
**Behind the apparent complexity, SuperClaude is actually simple to use.**
You don't need to learn all the commands, flags, and personas. Just start using it! 🎈
SuperClaude has an **intelligent routing system** that figures out what you need automatically:
- Type `/analyze some-code/` → It picks the right analysis tools
- Ask about security → Security expert auto-activates
- Work on frontend → UI specialist takes over
- Debug something → Investigation mode kicks in
**Learning emerges during use** - you'll naturally discover what works without studying manuals first.
The detailed guides below? They're here **when you want to understand** what just happened or dive deeper. But honestly? Most of the time you can just wing it. 😊
---
**TL;DR**: Install it, try `/analyze` or `/build` on your code, watch the magic happen.
---
A comprehensive guide to understanding and using SuperClaude v3.0 effectively. But remember - you can skip straight to trying it out!
## Table of Contents 📖 ## Table of Contents 📖
@ -18,43 +40,74 @@ A comprehensive guide to understanding and using SuperClaude v3.0 effectively. T
--- ---
## 🚀 Just Start Here
**Want to skip the reading and jump right in?** Here's your 2-minute getting started:
```bash
# Try these commands in Claude Code:
/help # See what's available
/analyze README.md # SuperClaude analyzes your project
/build # Smart build with auto-optimization
/improve messy-file.js # Clean up code automatically
```
**What just happened?** SuperClaude automatically:
- Picked the right tools for each task 🛠️
- Activated appropriate experts (security, performance, etc.) 🎭
- Applied intelligent flags and optimizations ⚡
- Provided evidence-based suggestions 📊
**See how easy that was?** No studying required - SuperClaude figures out the complexity so you don't have to.
Want to understand how it works? Keep reading. Want to just keep experimenting? Go for it! 🎯
---
## Welcome & Overview 👋 ## Welcome & Overview 👋
### What is SuperClaude Really? 🤔 ### What is SuperClaude Really? 🤔
SuperClaude is an enhancement framework for Claude Code that adds specialized capabilities through commands, smart personas, and external integrations. Think of it as giving Claude a toolkit and some expert consultants to help with development work. SuperClaude makes Claude Code smarter for development work. Instead of generic responses, you get specialized help from different experts (security, performance, frontend, etc.) who know their stuff.
**The honest truth**: We just released v3.0 and it's fresh out of beta. It works pretty well for what it does, but you should expect some rough edges as we continue improving things. We built this because we wanted Claude Code to be more helpful for real software development workflows. **The honest truth**: We just released v3.0 and it's fresh out of beta. It works pretty well for what it does, but you should expect some rough edges as we continue improving things. We built this because we wanted Claude Code to be more helpful for real software development workflows.
**The magic part?** You don't need to manage any of this complexity. Just use normal commands like `/analyze` or `/build` and SuperClaude automatically figures out which experts to involve and what tools to use. 🪄
### What SuperClaude Adds ✨ ### What SuperClaude Adds ✨
**🛠️ 15 Specialized Commands** **🛠️ 15 Specialized Commands** *(that auto-activate intelligently)*
- Development tools: `/build`, `/dev-setup`, `/design` - Development tools: `/build`, `/dev-setup`, `/design`
- Analysis tools: `/analyze`, `/review`, `/troubleshoot` - Analysis tools: `/analyze`, `/review`, `/troubleshoot`
- Quality tools: `/improve`, `/scan`, `/test` - Quality tools: `/improve`, `/scan`, `/test`
- Plus utilities for documentation, git, deployment, and more - Plus utilities for documentation, git, deployment, and more
- **You just use them** - SuperClaude handles the complexity automatically
**🎭 11 Smart Personas** **🎭 11 Smart Personas** *(that know when to jump in)*
- AI specialists that adapt behavior for different domains - AI specialists that adapt behavior for different domains
- Auto-activate based on your requests (security expert for security tasks, etc.) - **Auto-activate based on your requests** (security expert for security tasks, etc.)
- Manual control when you need a specific perspective - Manual control available, but usually not needed
- Think of it as having a whole dev team that knows when to help
**🔧 MCP Server Integration** **🔧 MCP Server Integration** *(smart external tools)*
- Context7: Official library documentation lookup - Context7: Official library documentation lookup
- Sequential: Complex multi-step analysis - Sequential: Complex multi-step analysis
- Magic: Modern UI component generation - Magic: Modern UI component generation
- Playwright: Browser automation and testing - Playwright: Browser automation and testing
- **Auto-connects when needed** - you don't manage this stuff
**📋 Enhanced Task Management** **📋 Enhanced Task Management** *(happens behind the scenes)*
- Progress tracking with TodoRead/TodoWrite - Progress tracking with TodoRead/TodoWrite
- Multi-session project management with `/task` - Multi-session project management with `/task`
- Complex orchestration with `/spawn` - Complex orchestration with `/spawn`
- Iterative improvement with `/loop` - Iterative improvement with `/loop`
- **Mostly automatic** - SuperClaude tracks what you're doing
**⚡ Token Optimization** **⚡ Token Optimization** *(smart efficiency)*
- Smart compression when context gets full - Smart compression when context gets full
- Symbol system for efficient communication - Symbol system for efficient communication
- Performance optimization for large operations - Performance optimization for large operations
- **Automatic activation** when needed for large projects
### Current Status (v3.0) 📊 ### Current Status (v3.0) 📊
@ -78,26 +131,31 @@ We're pretty happy with v3 as a foundation, but there's definitely room for impr
### How It Works 🔄 ### How It Works 🔄
SuperClaude enhances Claude Code through a combination of: **The simple version**: You type something like `/analyze auth.js` and SuperClaude figures out the rest.
1. **Documentation-driven behavior** - Framework files guide Claude's responses **The slightly more detailed version**:
2. **Intelligent routing** - The orchestrator system decides which tools and personas to use
3. **Auto-activation** - Commands, flags, and personas activate based on context
4. **External integrations** - MCP servers provide specialized capabilities
5. **Quality gates** - Validation and optimization throughout the process
The beauty is that most of this happens automatically. You make a request, SuperClaude figures out the best approach, and executes with appropriate tools and expertise. 1. **Smart routing** - Analyzes what you're asking for
2. **Auto-expert selection** - Picks the right specialist (security, performance, etc.)
3. **Tool coordination** - Connects to external systems when helpful
4. **Quality assurance** - Makes sure suggestions are solid
**You don't see any of this complexity** - it just feels like Claude got way smarter about development stuff.
The beauty is that most of this happens automatically. You make a request, SuperClaude figures out the best approach, and executes with appropriate tools and expertise. No configuration, no setup, no learning curve - just better results. ✨
### Quick Feature Overview 🎯 ### Quick Feature Overview 🎯
| Component | What It Does | Learn More | | Component | What It Does | Learn More *(optional!)* |
|-----------|--------------|------------| |-----------|--------------|------------|
| **Commands** | 15 specialized tools for development tasks | [Commands Guide](commands-guide.md) | | **Commands** | 15 specialized tools that auto-activate | [Commands Guide](commands-guide.md) |
| **Flags** | Modifiers that change command behavior | [Flags Guide](flags-guide.md) | | **Flags** | Modifiers that mostly activate automatically | [Flags Guide](flags-guide.md) |
| **Personas** | 11 AI specialists for different domains | [Personas Guide](personas-guide.md) | | **Personas** | 11 AI specialists that know when to help | [Personas Guide](personas-guide.md) |
| **MCP Servers** | External integrations for docs, UI, testing | [This guide](#core-components-🧩) | | **MCP Servers** | External integrations that connect when useful | [This guide](#core-components-🧩) |
| **Modes** | 3 operational modes for different needs | [This guide](#the-three-operational-modes-🎭) | | **Modes** | 3 operational modes for different workflows | [This guide](#the-three-operational-modes-🎭) |
| **Orchestrator** | Intelligent routing and optimization | [This guide](#the-orchestrator-system-🎯) | | **Orchestrator** | The smart routing that makes it all work | [This guide](#the-orchestrator-system-🎯) |
**Remember**: You can use SuperClaude effectively without reading any of these guides. They're here when you get curious about how the magic works! 🎪
--- ---