Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Tony363/SuperClaude --skill sc-design -a claude-code
Open on GitHub

What 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-db as 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-code

2Manually: put the files in place

~/.claude/skills/sc-design/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/sc-design/

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

Similar skills

All skills for Design →

From the same set8

agent-performance-engineer agent-performance-engineer is a Claude Code skill for finding bottlenecks and tuning applications, databases, and infrastructure. It activates for profiling, load testing, and performance work. CX Codex +1 556installs agent-security-engineer agent-security-engineer guides infrastructure security, CIS benchmark compliance, and CI/CD security scanning. Helps teams introduce DevSecOps and zero-trust controls. CX Codex +1 402installs sc-estimate sc-estimate turns a task, feature or migration into a time, effort or complexity estimate with a confidence range and the risks behind it. CX Codex +1 184installs agent-fullstack-developer agent-fullstack-developer guides the coding assistant through end-to-end feature delivery, linking database schemas, typed APIs, and UI components in one workflow. CX Codex +1 155installs agent-technical-writer agent-technical-writer is a Claude Code skill for API docs, user guides, and technical content. It activates for technical writing, implementation guidance, and best-practice tasks. CX Codex +1 108installs agent-react-specialist agent-react-specialist gives the agent a senior React role: React 18+ patterns, advanced hooks, server components, plus a checklist for performance and tests. CX Codex +1 107installs agent-kubernetes-specialist The agent-kubernetes-specialist skill supports Kubernetes cluster design, workload orchestration, security hardening, and performance work for production infrastructure. CX Codex +1 101installs

Project sponsors

Companies that keep this analytics open