sc-design — Claude Code skill: what it does, how to install
sc-design is a Claude Code skill for designing system architecture, APIs, component interfaces, and database schemas. Choose a design type and request a diagram, specification, or code.
MIT 113 installs ★ 21 updated 2026-06-29
npx skills add Tony363/SuperClaude --skill sc-design -a claude-codeWhat sc-design does
sc-design examines requirements and the existing system context, then produces design materials. For architecture, it maps system structure and component relationships. For APIs, it outlines endpoints and request and response schemas; for databases, it documents entity relationships and constraints. Results can take the form of diagrams, specifications, or code.
The skill also describes PAL MCP for planning and reviewing design choices, and Rube MCP for sharing materials and collaboration. Those workflows use MCP tools, so they depend on the relevant servers. The design formats described by the skill remain available as separate options.
Call it with /sc:design, a target, and the --type and --format flags. For instance, api with spec requests an API specification, while database with diagram asks for a database diagram.
What it helps with
- map an architecture and component relationships
- specify API endpoints and request and response schemas
- define component interfaces and dependencies
- model database relationships and constraints
- produce a design diagram or specification
Example prompts for the agent
- Draft an architecture diagram for
user-management:/sc:design user-management --type architecture --format diagram. - Write an API specification for
payment-api:/sc:design payment-api --type api --format spec. - Model
inventory-dbas a diagram:/sc:design inventory-db --type database --format diagram.
How to install sc-design
1Skills CLI (Vercel)
npx skills add Tony363/SuperClaude --skill sc-design -a claude-code2Manually: put the files in place
~/.claude/skills/sc-design/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/sc-design/
1Skills CLI (Vercel)
npx skills add Tony363/SuperClaude --skill sc-design -a codex2Manually: put the files in place
.agents/skills/sc-design/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Tony363/SuperClaude --skill sc-design -a cursor2Manually: put the files in place
.cursor/skills/sc-design/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Tony363/SuperClaude .claude/skills/sc-design2Manually: put the files in place
.github/skills/sc-design/SKILL.md1Skills CLI (Vercel)
npx skills add Tony363/SuperClaude --skill sc-design -a gemini-cli2Platform CLI
gemini skills install https://github.com/Tony363/SuperClaude --path .claude/skills/sc-designManually: put the files in place
.devin/skills/sc-design/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add Tony363/SuperClaude --skill sc-design -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about sc-design
How do I install sc-design in Claude Code?
Run npx skills add Tony363/SuperClaude --skill sc-design -a claude-code. The skill file is at ~/.claude/skills/sc-design/SKILL.md.
What does sc-design do?
It supports design work for system architecture, APIs, component interfaces, and database schemas. You can request diagrams, specifications, or code.
Does sc-design require PAL MCP or Rube MCP?
Those integrations support extra workflows: PAL MCP helps plan and review design decisions, while Rube MCP handles sharing and collaboration. The skill also describes its core design output formats separately.
Source text
SKILL.md · MIT
---
name: sc-design
description: Design system architecture, APIs, and component interfaces with comprehensive specifications. Use when planning architecture, designing APIs, creating component interfaces, or modeling databases.
---
# System & Component Design Skill
Architecture planning and interface design with industry best practices.
## Quick Start
```bash
# Architecture design
/sc:design [target] --type architecture
# API specification
/sc:design payment-api --type api --format spec
# Database schema
/sc:design e-commerce --type database --format diagram
```
## Behavioral Flow
1. **Analyze** - Examine requirements and existing system context
2. **Plan** - Define design approach based on type and format
3. **Design** - Create specifications with best practices
4. **Validate** - Ensure maintainability and scalability
5. **Document** - Generate diagrams and specifications
## Flags
| Flag | Type | Default | Description |
|------|------|---------|-------------|
| `--type` | string | architecture | architecture, api, component, database |
| `--format` | string | spec | diagram, spec, code |
## Evidence Requirements
This skill does NOT require hard evidence. Deliverables are:
- Design specifications and diagrams
- Interface definitions
- Schema documentation
## Design Types
### Architecture (`--type architecture`)
- System structure and component relationships
- Scalability and reliability patterns
- Service boundaries and communication
### API (`--type api`)
- RESTful/GraphQL endpoint design
- Request/response schemas
- Authentication and versioning
### Component (`--type component`)
- Interface contracts and dependencies
- State management patterns
- Integration points
### Database (`--type database`)
- Entity relationships and constraints
- Normalization and indexing
- Performance considerations
## Output Formats
### Diagram (`--format diagram`)
- ASCII or Mermaid diagrams
- Component relationship visualization
- Data flow representation
### Specification (`--format spec`)
- OpenAPI/Swagger for APIs
- Detailed interface documentation
- Technical requirements
### Code (`--format code`)
- Interface definitions
- Type declarations
- Skeleton implementations
## Examples
### System Architecture
```
/sc:design user-management --type architecture --format diagram
# Component relationships, data flow, scalability patterns
```
### API Design
```
/sc:design payment-api --type api --format spec
# OpenAPI spec with endpoints, schemas, auth patterns
```
### Component Interface
```
/sc:design notification-service --type component --format code
# TypeScript/Python interfaces with clear contracts
```
### Database Schema
```
/sc:design inventory-db --type database --format diagram
# ER diagrams with relationships and constraints
```
## MCP Integration
### PAL MCP (Design Validation)
| Tool | When to Use | Purpose |
|------|-------------|---------|
| `mcp__pal__planner` | Architecture planning | Sequential planning with branching for design decisions |
| `mcp__pal__consensus` | Design decisions | Multi-model validation of architectural choices |
| `mcp__pal__thinkdeep` | Complex systems | Deep analysis of system requirements |
| `mcp__pal__chat` | Brainstorming | Collaborative design exploration |
| `mcp__pal__apilookup` | API standards | Get current API design best practices |
### PAL Usage Patterns
```bash
# Architecture planning
mcp__pal__planner(
step="Designing microservices architecture for e-commerce platform",
step_number=1,
total_steps=4,
more_steps_needed=True
)
# Validate design with consensus
mcp__pal__consensus(
models=[
{"model": "gpt-5.2", "stance": "for"},
{"model": "gemini-3-pro", "stance": "against"},
{"model": "deepseek", "stance": "neutral"}
],
step="Evaluate: Should we use event sourcing for the order management system?"
)
# Deep system analysis
mcp__pal__thinkdeep(
step="Analyzing scalability requirements for real-time notification system",
hypothesis="WebSocket with Redis pub/sub will handle 100k concurrent users",
confidence="medium",
focus_areas=["scalability", "reliability", "performance"]
)
```
### Rube MCP (Documentation & Collaboration)
| Tool | When to Use | Purpose |
|------|-------------|---------|
| `mcp__rube__RUBE_SEARCH_TOOLS` | External tools | Find diagramming, documentation tools |
| `mcp__rube__RUBE_MULTI_EXECUTE_TOOL` | Share designs | Post to Notion, Confluence, Slack |
| `mcp__rube__RUBE_CREATE_UPDATE_RECIPE` | Design workflows | Save reusable design processes |
### Rube Usage Patterns
```bash
# Create design document in Notion
mcp__rube__RUBE_SEARCH_TOOLS(queries=[
{"use_case": "create notion page", "known_fields": "database:Architecture"}
])
mcp__rube__RUBE_MULTI_EXECUTE_TOOL(tools=[
{"tool_slug": "NOTION_CREATE_PAGE", "arguments": {
"title": "Payment API Design v2",
"content": "## Overview\n..."
}}
])
# Share design for review
mcp__rube__RUBE_MULTI_EXECUTE_TOOL(tools=[
{"tool_slug": "SLACK_SEND_MESSAGE", "arguments": {
"channel": "#architecture",
"text": "New design ready for review: Payment API v2"
}},
{"tool_slug": "JIRA_CREATE_ISSUE", "arguments": {
"project": "ARCH",
"summary": "Review: Payment API Design",
"issue_type": "Task"
}}
])
```
## Flags (Extended)
| Flag | Type | Default | Description |
|------|------|---------|-------------|
| `--pal-plan` | bool | false | Use PAL planner for systematic design |
| `--consensus` | bool | false | Validate design with multi-model consensus |
| `--share` | string | - | Share via Rube (notion, confluence, slack) |
| `--create-ticket` | bool | false | Create review ticket via Rube |
## Tool Coordination
- **Read** - Requirements analysis
- **Grep/Glob** - Pattern analysis
- **Write** - Design documentation
- **Bash** - External tool integration
- **PAL MCP** - Design planning, consensus validation, deep analysis
- **Rube MCP** - Documentation sharing, collaboration, review workflows
© Tony363 · MIT · Tony363/SuperClaude