design — Claude Code command: what it does, how to install
design plans system architecture, API specifications, and database schemas before coding starts. Useful for creating technical contracts and component diagrams.
MIT ★ 23,950 updated 2026-09-27
.claude/commands/design.mdWhat design does
The command inspects the project context to prepare technical specifications. It relies on file reading alongside grep or glob searches to understand the existing codebase. External tools run via bash when needed.
Output depends on the --type and --format flags. You can model RESTful interfaces, database schemas, or service boundaries. The result lands in architecture documents containing diagrams and interface contracts.
This command produces no production code. It stays strictly within design specifications. To build the components, switch to /sc:implement.
What it helps with
- document system architecture with component relationships
- draft RESTful or GraphQL API specifications
- structure database schemas with table relations
- define service boundaries and component interfaces
Example prompts for the agent
- /sc:design user-management-system --type architecture --format diagram
- /sc:design payment-api --type api --format spec
- /sc:design e-commerce-db --type database --format diagram
How to install design
Manually: put the files in place
.claude/commands/design.mdCall it with /design. For all projects use ~/.claude/commands/
Manually: put the files in place
~/.codex/prompts/design.mdCall it with /prompts:design. Codex marks this format deprecated in favour of skills
Manually: put the files in place
.github/prompts/design.prompt.mdManually: put the files in place
.gemini/commands/design.tomlGemini stores commands as TOML: the prompt text goes into the prompt field
Questions about design
How to install design in Claude Code?
Place the file at .claude/commands/design.md. Once saved, the command is ready to use in your Claude Code session.
What does the /sc:design command do?
It generates architecture specifications, sequence diagrams, and data models before implementation. This helps validate system structure and constraints early.
Does the command generate production code?
No, it focuses exclusively on design documents and interface definitions. Once the architecture is settled, use /sc:implement to write the actual code.
Source text
design.md · MIT
--- name: design description: "Design system architecture, APIs, and component interfaces with comprehensive specifications" category: utility complexity: basic mcp-servers: [] personas: [] --- # /sc:design - System and Component Design ## Triggers - Architecture planning and system design requests - API specification and interface design needs - Component design and technical specification requirements - Database schema and data model design requests ## Usage ``` /sc:design [target] [--type architecture|api|component|database] [--format diagram|spec|code] ``` ## Behavioral Flow 1. **Analyze**: Examine target requirements and existing system context 2. **Plan**: Define design approach and structure based on type and format 3. **Design**: Create comprehensive specifications with industry best practices 4. **Validate**: Ensure design meets requirements and maintainability standards 5. **Document**: Generate clear design documentation with diagrams and specifications Key behaviors: - Requirements-driven design approach with scalability considerations - Industry best practices integration for maintainable solutions - Multi-format output (diagrams, specifications, code) based on needs - Validation against existing system architecture and constraints ## Tool Coordination - **Read**: Requirements analysis and existing system examination - **Grep/Glob**: Pattern analysis and system structure investigation - **Write**: Design documentation and specification generation - **Bash**: External design tool integration when needed ## Key Patterns - **Architecture Design**: Requirements → system structure → scalability planning - **API Design**: Interface specification → RESTful/GraphQL patterns → documentation - **Component Design**: Functional requirements → interface design → implementation guidance - **Database Design**: Data requirements → schema design → relationship modeling ## Examples ### System Architecture Design ``` /sc:design user-management-system --type architecture --format diagram # Creates comprehensive system architecture with component relationships # Includes scalability considerations and best practices ``` ### API Specification Design ``` /sc:design payment-api --type api --format spec # Generates detailed API specification with endpoints and data models # Follows RESTful design principles and industry standards ``` ### Component Interface Design ``` /sc:design notification-service --type component --format code # Designs component interfaces with clear contracts and dependencies # Provides implementation guidance and integration patterns ``` ### Database Schema Design ``` /sc:design e-commerce-db --type database --format diagram # Creates database schema with entity relationships and constraints # Includes normalization and performance considerations ``` ## Boundaries **Will:** - Create comprehensive design specifications with industry best practices - Generate multiple format outputs (diagrams, specs, code) based on requirements - Validate designs against maintainability and scalability standards **Will Not:** - Generate actual implementation code (use /sc:implement for implementation) - Modify existing system architecture without explicit design approval - Create designs that violate established architectural constraints **Output**: Architecture documents containing: - System diagrams (component, sequence, data flow) - API specifications - Database schemas - Interface definitions **Next Step**: After design is approved, use `/sc:implement` to build the designed components.
© SuperClaude-Org · MIT · SuperClaude-Org/SuperClaude_Framework