Zum Inhalt

SuperClaude

generieren

Umfassende SuperClaude Befehle und Workflows für eine verbesserte Claude Code Entwicklung mit spezialisierten Befehlen, kognitiven Personen und evidenzbasierten Methoden.

Überblick

SuperClaude ist ein Open-Source-Rahmen, der erweitert Claude Code mit 19 spezialisierten Befehlen, 9 kognitiven Personen und evidenzbasierten Entwicklungsmethoden. Es wendet sich an Software-Engineering-Prinzipien, ohne zusätzliche Code- oder externe Tools zu benötigen, um Claude Code in einen leistungsstärkeren Entwicklungsassistenten mit erweitertem Kontextmanagement, Tokenoptimierung und modularen Workflows zu verwandeln.

ZEIT ** Nutzungshinweis*: SuperClaude verbessert Claude Code-Fähigkeiten sollten aber neben ordnungsgemäßen Tests, Code-Reviews und Sicherheitspraktiken verwendet werden. Immer validieren Sie AI-generierten Code vor der Produktion.

Installation

Quick Setup

```bash

Clone SuperClaude repository

git clone https://github.com/NomenAK/SuperClaude.git cd SuperClaude

Copy configuration to Claude Code directory

cp superclaude.md ~/.claude/

Initialize SuperClaude in your project

claude-code --config superclaude.md ```_

Manuelle Konfiguration

```bash

Create SuperClaude config directory

mkdir -p ~/.superclaude

Download configuration files

curl -o ~/.superclaude/config.md https://raw.githubusercontent.com/NomenAK/SuperClaude/main/superclaude.md

Set environment variable

export SUPERCLAUDE_CONFIG=~/.superclaude/config.md ```_

Kernkommandos

Command Description
/architect Activate architect persona for system design
/security Enable security expert persona for code review
/optimizer Switch to performance optimization persona
/debugger Activate debugging specialist persona
/tester Enable testing expert persona
/docs Activate documentation specialist persona
/reviewer Switch to code review expert persona
/mentor Enable teaching and mentoring persona
/researcher Activate research and analysis persona

Spezialisierte Befehle

Kontextmanagement

Command Description
/context7 Research and documentation tool
/checkpoint Create development checkpoint
/history View development history
/compress Enable UltraCompressed mode
/expand Expand compressed context
/focus Focus on specific code area
/scope Define project scope

Entwicklungs-Workflows

Command Description
/sequential Enable deep thinking and analysis
/parallel Run parallel development tasks
/wave Orchestrate complex workflows
/modular Enable modular development approach
/iterative Use iterative development cycle
/validate Validate code and architecture

Landkarten von Persona

Architektur Persona

```bash

Activate architect persona

claude-code --persona-architect

System design commands

/architect --design-system /architect --review-architecture /architect --optimize-structure ```_

Sicherheitspersonen

```bash

Enable security expert

claude-code --persona-security

Security analysis commands

/security --audit-code /security --check-vulnerabilities /security --review-permissions ```_

Leistungsperson

```bash

Activate optimizer

claude-code --persona-optimizer

Performance commands

/optimizer --analyze-performance /optimizer --optimize-queries /optimizer --reduce-complexity ```_

Erweiterte Funktionen

Token Optimierung

```bash

Enable token optimization

/compress --ultra

Optimize conversation context

/context7 --optimize

Reduce token usage

/focus --narrow-scope ```_

Modulare Entwicklung

```bash

Initialize modular structure

/modular --init

Create module

/modular --create module_name

Link modules

/modular --link module1 module2 ```_

Dokumentation Generation

```bash

Generate project documentation

/docs --generate-all

Create API documentation

/docs --api-docs

Generate README

/docs --readme ```_

Konfigurationsoptionen

Grundkonfiguration

```yaml

~/.superclaude/config.yaml

personas: default: architect available: [architect, security, optimizer, debugger, tester, docs, reviewer, mentor, researcher]

features: token_optimization: true modular_development: true checkpoint_system: true ultra_compressed: false

workflows: sequential_thinking: true parallel_processing: false wave_orchestration: true ```_

Erweiterte Einstellungen

```yaml

Advanced SuperClaude configuration

context: max_tokens: 200000 compression_ratio: 0.7 focus_depth: 3

development: checkpoint_frequency: 10 auto_documentation: true code_validation: true security_checks: true

personas: architect: focus: [system_design, architecture_patterns, scalability] security: focus: [vulnerability_assessment, secure_coding, compliance] optimizer: focus: [performance_tuning, resource_optimization, efficiency] ```_

Beispiele für Workflow

Vollständige Stack-Entwicklung

```bash

Initialize project with architect persona

claude-code --persona-architect /architect --design-system "e-commerce platform"

Switch to security review

/security --audit-design

Implement with optimizer

/optimizer --implement-efficient

Test with tester persona

/tester --comprehensive-testing

Document with docs persona

/docs --generate-complete ```_

Code Review Workflow

```bash

Start code review session

claude-code --persona-reviewer

Analyze code quality

/reviewer --analyze-quality

Check security issues

/security --vulnerability-scan

Performance review

/optimizer --performance-review

Generate review report

/docs --review-report ```_

Diskussionsrunde

```bash

Activate debugger persona

claude-code --persona-debugger

Analyze error

/debugger --analyze-error "error_message"

Trace execution

/debugger --trace-execution

Suggest fixes

/debugger --suggest-fixes

Validate solution

/tester --validate-fix ```_

Integration mit Claude Code

Verbesserte Befehle

```bash

SuperClaude enhanced file operations

claude-code edit --persona-architect file.py claude-code create --persona-security auth.py claude-code review --persona-reviewer codebase/

Context-aware development

claude-code --context7 --focus-area authentication claude-code --sequential --deep-analysis claude-code --wave --orchestrate-features ```_

Projektvorlagen

```bash

Create project with SuperClaude template

claude-code create-project --template superclaude-fullstack claude-code create-project --template superclaude-api claude-code create-project --template superclaude-frontend

Initialize existing project

claude-code init --superclaude ```_

Best Practices

Auswahl der Person

  • **Architect*: Systemdesign, Architekturplanung, Skalierbarkeitsentscheidungen
  • Sicherheit: Code Audits, Sicherheitsbewertung, sichere Kodierung
  • Optimizer: Leistungsabstimmung, Ressourcenoptimierung, Effizienz
  • Debugger: Fehleranalyse, Fehlersuche, Problemlösung
  • Tester: Testplanung, Qualitätssicherung, Validierung
  • Docs: Dokumentation, API-Spezifikationen, Benutzerführungen
  • Reviewer: Codeüberprüfung, Qualitätsbewertung, Best Practices
  • Mentor: Lernberatung, Erklärung, Lehre
  • Forschung: Analyse, Untersuchung, Forschungsaufgaben

Token Management

```bash

Optimize token usage

/compress --smart-compression /focus --relevant-context /checkpoint --save-state

Monitor token consumption

/context7 --token-usage /history --token-analysis ```_

Entwicklung Lebenszyklus

```bash

1. Planning phase

/architect --plan-project

2. Implementation phase

/optimizer --implement-efficient

3. Security phase

/security --security-review

4. Testing phase

/tester --comprehensive-testing

5. Documentation phase

/docs --complete-documentation

6. Review phase

/reviewer --final-review ```_

Fehlerbehebung

Gemeinsame Themen

```bash

Reset SuperClaude configuration

claude-code --reset-superclaude

Clear context cache

/context7 --clear-cache

Rebuild persona profiles

/persona --rebuild-all

Validate configuration

/validate --config-check ```_

Leistungsoptimierung

```bash

Optimize SuperClaude performance

/optimizer --superclaude-performance

Reduce memory usage

/compress --memory-optimization

Speed up responses

/focus --performance-mode ```_

Debug Mode

```bash

Enable SuperClaude debug mode

claude-code --debug-superclaude

Verbose logging

/debugger --verbose-logging

Trace persona switching

/persona --trace-switches ```_

Advanced Use Cases

Multi-Agent-Entwicklung

```bash

Coordinate multiple personas

/wave --multi-agent-coordination

Parallel development streams

/parallel --architect --security --optimizer

Sequential expert consultation

/sequential --architect -> /security -> /optimizer ```_

Unternehmensintegration

```bash

Enterprise configuration

claude-code --enterprise-superclaude

Team collaboration

/wave --team-coordination

Compliance checking

/security --compliance-audit

Documentation standards

/docs --enterprise-standards ```_

Benutzerdefinierte Workflows

```bash

Create custom workflow

/wave --create-workflow "custom_dev_flow"

Define workflow steps

/wave --add-step "architect_review" /wave --add-step "security_check" /wave --add-step "performance_optimization"

Execute custom workflow

/wave --execute "custom_dev_flow" ```_

Ressourcen