SuperClaude Framework

Source: Superclaude Org Superclaude Framework 2026 04 26

Repo: https://github.com/SuperClaude-Org/SuperClaude_Framework Website: https://superclaude.netlify.app/ Version: 4.3.0 (current stable) Stars: 22,492 (at time of ingest 2026-04-26) License: MIT Anthropic affiliation: None — explicitly disclaimed in the README.

SuperClaude is a community meta-programming configuration framework that bolts a structured development platform onto Claude Code via behavioral instruction injection and component orchestration. Where Superpowers is a closed methodology and oh-my-claudecode is an orchestration runtime, SuperClaude is configurable surface area: 30 /sc:* slash commands, 20 specialized agents, 7 behavioral modes, and 8 MCP-server integrations the user composes themselves. v4.x ships via pipx as a Python package; v5.0 (in development) is moving to a TypeScript plugin-marketplace install.

Key Takeaways

• Configurable, not opinionated. SuperClaude exposes commands, agents, modes, and MCP servers as composable parts. The user picks /sc:research or /sc:implement or /sc:business-panel like a menu — opposite shape to Superpowers’ auto-triggering closed methodology.
• 30 slash commands organized by lifecycle phase. Planning & Design (4) → Development (5) → Testing & Quality (4) → Documentation (2) → Version Control (1) → Project Management (3) → Research & Analysis (2) → Utilities (9). Commands install in the /sc:* namespace after superclaude install.
• 20 specialized agents. Domain-aware roles: PM Agent, Deep Research, Security Engineer, Frontend Architect, plus 16 others. The framework auto-coordinates which agent handles which sub-task.
• 7 behavioral modes — Brainstorming, Business Panel, Deep Research, Orchestration, Token-Efficiency, Task Management, Introspection. Modes are not commands; they’re cognitive postures the framework can shift into per request.
• 8 MCP server integrations. Tavily, Context7, Sequential-Thinking, Serena, Playwright, Magic, Morphllm-Fast-Apply, Chrome DevTools. CLI-installable: superclaude mcp --servers tavily context7. Optional but advertised at “2-3× faster, 30-50% fewer tokens.”
• Deep Research is a v4.2 flagship. /research runs autonomous web research with 4 depth tiers (Quick/Standard/Deep/Exhaustive — 5–40+ sources, 1–5 hops, ~2–10 min) and 3 planning strategies (planning-only / intent-planning / unified). Coordinates Tavily + Playwright + Sequential + Serena + Context7.
• Not on the official Claude marketplace. Distributed via PyPI / npm / Smithery / git-clone. Manual install (pipx install superclaude && superclaude install) — the user is opting in deliberately, not picking from Anthropic’s vetted catalog.
• v5.0 will move to TypeScript plugin distribution. GitHub issue #419 tracks the migration to /plugin marketplace add SuperClaude-Org/superclaude-plugin-marketplace. No ETA. The README warns explicitly that older docs reference v5 install paths that don’t yet work.
• Sister frameworks for other models. SuperGemini_Framework and SuperQwen_Framework apply the same pattern to Gemini and Qwen — useful signal that the architecture is intentionally model-portable.
• 22.5k stars, 1.9k forks. Active community framework, mid-tier scale (vs Superpowers’ 168k or oh-my-claudecode’s 30k).

Architecture: how the four primitives compose

You type:                          /sc:research "Claude Code Routines security model"
SuperClaude routes to:             ↓
   Mode:        Deep Research              (cognitive posture)
   Agent:       Deep Research agent        (specialist persona)
   Command:     /sc:research               (lifecycle entry point)
   MCP servers: Tavily + Context7 + Serena (operational tools)

The command picks the lifecycle phase. The mode sets the cognitive posture. The agent provides domain expertise. The MCP servers are the operational primitives. The framework’s job is wiring those four together so the user gets the result of a research project, not a raw web search.

How it fits the Claude Code stack

• vs Superpowers: Opposite shapes. Superpowers is closed, opinionated methodology that triggers automatically. SuperClaude is open, configurable surface area the user invokes explicitly. SuperClaude is also bigger in component count (30 commands vs 14 skills) but smaller in distribution trust (community PyPI vs Anthropic-marketplace official).
• vs oh-my-claudecode: Both are mid-scale community frameworks. OMC is orchestration-first (modes, parallelism, multi-model bridges). SuperClaude is configuration-first (commands, agents, behavioral postures). OMC is louder; SuperClaude is more componentized.
• vs Agent Teams (native): Agent Teams is Anthropic’s experimental multi-instance primitive. SuperClaude’s 20 agents are configured personas using normal subagents — they don’t depend on Teams, but they could compose with it.
• vs Claude Code Plugins: SuperClaude is not a plugin in the v4.x line — it’s a Python package that injects behavior. v5.0 plans to ship as a plugin so it can be installed via /plugin install superclaude like everything else.
• vs Agent Skills (open standard): Skills are Anthropic’s open standard for procedural Markdown instructions. SuperClaude’s commands are a parallel layer — not Anthropic Skills format, distinct namespace (/sc:*), distinct authoring conventions. The frameworks coexist but don’t share files.
• vs Essential MCP Servers: SuperClaude’s 8 servers overlap heavily with the canonical MCP-server shortlist (Tavily, Context7, Sequential, Serena, Playwright). The framework essentially curates its preferred MCP set and bundles installation into one CLI.
• vs Scheduled Tasks / Routines: SuperClaude’s /research and /business-panel modes are interactive command flows. Routines and /loop are durable scheduled triggers. Different timeline shapes — pair them by scheduling a Routine that calls /sc:research on a cadence.

Installation

Current stable (v4.3.0) — pipx

pipx install superclaude
superclaude install                   # registers all 30 /sc:* slash commands
superclaude mcp --servers tavily context7   # optional MCP servers
superclaude doctor                    # verify install

After installation, restart Claude Code. Commands appear under the /sc:* namespace — /sc:research, /sc:brainstorm, /sc:implement, /sc:test, /sc:pm, /sc (lists all).

Direct from git

git clone https://github.com/SuperClaude-Org/SuperClaude_Framework.git
cd SuperClaude_Framework
./install.sh

v5.0 (in development, not yet shipping)

# Not yet available — issue #419 tracking
/plugin marketplace add SuperClaude-Org/superclaude-plugin-marketplace
/plugin install superclaude

The README explicitly warns that older docs reference this path; ignore until v5.0 ships.

The 30 commands at a glance

Planning & Design (4) — /brainstorm, /design, /estimate, /spec-panel Development (5) — /implement, /build, /improve, /cleanup, /explain Testing & Quality (4) — /test, /analyze, /troubleshoot, /reflect Documentation (2) — /document, /help Version Control (1) — /git Project Management (3) — /pm, /task, /workflow Research & Analysis (2) — /research, /business-panel Utilities (9) — /agent, /index-repo, /index, /recommend, /select-tool, /spawn, /load, /save, /sc

(All commands prefix with /sc: once installed — e.g., /sc:research.)

The 7 behavioral modes

• Brainstorming — Asks the right questions before answering.
• Business Panel — Multi-expert strategic analysis (legal/marketing/finance personas).
• Deep Research — Autonomous multi-hop web research with quality scoring.
• Orchestration — Efficient tool coordination across MCP servers.
• Token-Efficiency — 30-50% context savings via terse-mode operation.
• Task Management — Systematic organization, dependencies, sub-tasks.
• Introspection — Meta-cognitive analysis of the agent’s own reasoning.

Modes layer on top of commands — /sc:research in Deep Research mode behaves differently than the same command in Token-Efficiency mode.

Deep Research subsystem (v4.2)

The flagship feature in v4.2. /research (or /sc:research) runs autonomous web research aligned with the broader DR Agent architecture pattern.

Depth	Sources	Hops	Time	Best For
Quick	5-10	1	~2 min	Quick facts, simple queries
Standard	10-20	3	~5 min	General research (default)
Deep	20-40	4	~8 min	Comprehensive analysis
Exhaustive	40+	5	~10 min	Academic-level research

Three planning strategies:

• Planning-Only — direct execution for clear queries
• Intent-Planning — clarification first for ambiguous requests
• Unified (default) — collaborative plan refinement

Quality gating: source credibility (0.0–1.0), coverage completeness, synthesis coherence. Minimum threshold 0.6, target 0.8. Multi-hop reasoning chains entity expansion, concept deepening, temporal progression, causal chains. Cross-session learning saves successful query formulations.

Optional MCP performance pack (airis-mcp-gateway)

For 2-3× faster execution and 30-50% token reduction, the framework integrates with airis-mcp-gateway:

• Serena (code understanding)
• Sequential (reasoning)
• Tavily (web search)
• Context7 (docs lookup)
• Mindbase (semantic search across past conversations — optional)

Without these MCPs, SuperClaude is fully functional. Pure speed-up layer.

When to use it

• You want a richer command palette than Claude Code ships out of the box, with sane defaults curated by a community framework.
• You’re doing research-heavy work and want a turnkey deep-research command with quality scoring.
• You want behavioral modes (Token-Efficiency, Business Panel, Introspection) as a deliberate tool, not as ad-hoc prompting.
• You’re already running an MCP gateway and want a framework that takes advantage of it.

When not to use it

• You want Anthropic-vetted distribution — pick Superpowers (on the official marketplace) or stay with Anthropic-built plugins.
• You want auto-triggered methodology — pick Superpowers (skills auto-activate, no /cmd invocations).
• You want true multi-agent orchestration with inter-agent communication — pick oh-my-claudecode or native Agent Teams.
• You don’t want to manage a Python install path — wait for v5.0’s plugin distribution.
• You can’t accept “not affiliated with Anthropic” risk for production work — the README explicitly disclaims affiliation, and the framework injects behavioral instructions across your sessions.

Tradeoffs

• Manual install + namespace pollution. 30 /sc:* commands appear in your slash-command picker. If you also run OMC or Superpowers, the namespace can crowd quickly. Audit the picker after install.
• Behavioral injection is opaque. The framework injects instructions into Claude Code via superclaude install. Diagnosing “why is Claude behaving this way?” requires reading SuperClaude’s instructions, which are not part of your project repo.
• Community trust, not Anthropic trust. The “not affiliated” disclaimer is correct and important. Treat behavioral injection from a third party with the same scrutiny you’d give any other open-source dependency that runs in your dev loop.
• v4 → v5 transition risk. The TypeScript plugin migration is a major architectural change. Lock to v4.3.0 explicitly if you’re depending on a stable surface, and watch issue #419 before upgrading.

Related

• Superpowers — Agentic Skills Framework — sibling third-party Claude Code framework; opposite shape (closed methodology vs configurable surface)
• oh-my-claudecode — sibling third-party framework focused on multi-agent orchestration
• Claude Code Plugins and Marketplaces — v5.0 will distribute as a plugin; today is pipx-installed
• Essential MCP Servers — SuperClaude bundles a curated subset of these via superclaude mcp
• Agent Skills Overview — distinct from SuperClaude’s command/agent layer; the two coexist
• Managed Agents — Anthropic’s hosted agent service; SuperClaude’s 20 agents are local subagents, not managed
• Claude Code Subagents — SuperClaude’s agent system layers on this primitive
• Claude Code Agent Teams — native multi-instance coordination; SuperClaude doesn’t require it but can compose with it
• Claude Code CLI Reference — the binary SuperClaude extends
• Skills vs MCP vs Plugins — decision framework for placing SuperClaude on the spectrum
• _index

Try It

1. Install: pipx install superclaude && superclaude install. Restart Claude Code.
2. Type /sc to see all 30 commands. Spend 5 minutes scanning them — most users only end up using 5–8 regularly.
3. Run /sc:research "your-actual-question" at default Standard depth. Compare quality and time vs raw WebSearch from a normal prompt.
4. Pick one behavioral mode that maps to a recurring need — Token-Efficiency for long sessions, Deep Research for investigation, Business Panel for strategy. Use it deliberately on the next matching task.
5. Optional: install Tavily + Context7 via superclaude mcp --servers tavily context7 to unlock the advertised speed/token gains. Compare a /sc:research run before vs after.
6. Audit your slash-command picker — if SuperClaude clashes with your existing commands, decide which namespace stays.

Open Questions

• How does SuperClaude’s behavioral instruction injection interact with project-level hooks and CLAUDE.md? Does it stack additively or override, and in which order?
• The 8 advertised MCP servers overlap heavily with the essential MCP shortlist — does superclaude mcp install conflict with existing MCP server registrations?
• v5.0 ETA is unspecified. What does the v4 → v5 migration look like for a project that has scripted /sc:* commands into hooks or routines?
• Are the 20 agents actually distinct subagent definitions, or are they personas the framework dispatches via prompts? The README implies the former; verifying would clarify how they compose with Agent Teams.
• Performance claims (“2-3× faster, 30-50% fewer tokens”) with the optional MCP pack — has anyone independently benchmarked these on representative workloads?