system-design
npx machina-cli add skill anthropics/knowledge-work-plugins/system-design --openclawSystem Design
Help design systems and evaluate architectural decisions.
Framework
1. Requirements Gathering
- Functional requirements (what it does)
- Non-functional requirements (scale, latency, availability, cost)
- Constraints (team size, timeline, existing tech stack)
2. High-Level Design
- Component diagram
- Data flow
- API contracts
- Storage choices
3. Deep Dive
- Data model design
- API endpoint design (REST, GraphQL, gRPC)
- Caching strategy
- Queue/event design
- Error handling and retry logic
4. Scale and Reliability
- Load estimation
- Horizontal vs. vertical scaling
- Failover and redundancy
- Monitoring and alerting
5. Trade-off Analysis
- Every decision has trade-offs. Make them explicit.
- Consider: complexity, cost, team familiarity, time to market, maintainability
Output
Produce clear, structured design documents with diagrams (ASCII or described), explicit assumptions, and trade-off analysis. Always identify what you'd revisit as the system grows.
Source
git clone https://github.com/anthropics/knowledge-work-plugins/blob/main/engineering/skills/system-design/SKILL.mdView on GitHub Overview
System Design helps teams design systems and evaluate architectural decisions across requirements, high-level structure, and deep technical details. It emphasizes clear trade-offs, scalable patterns, and producing structured design documents with diagrams, explicit assumptions, and revisiting plans as the system grows.
How This Skill Works
It guides you through Requirements, High-Level Design, Deep Dive, Scale & Reliability, and Trade-offs, then produces a clear design document with diagrams or ASCII, explicit assumptions, and revisiting notes.
When to Use It
- When you need to design a system for a new product or feature.
- When deciding how to architect services, APIs, and data models.
- When evaluating scalability, reliability, and cost trade-offs.
- When choosing between REST, GraphQL, or gRPC and storage options.
- When defining service boundaries and data flows across teams.
Quick Start
- Step 1: Gather requirements (functional, non-functional, constraints) and document them.
- Step 2: Create a high-level design with components, data flows, and API contracts.
- Step 3: Deep dive into data models, endpoints, caching, queues, and error handling; draft the design document with trade-offs and revisit notes.
Best Practices
- Start from clear requirements and non-functional constraints (scale, latency, availability, cost).
- Draw component diagrams and data flows early to align stakeholders.
- Define API contracts and data models before coding begins.
- Explicitly document trade-offs, focusing on complexity, cost, and maintainability.
- Identify what you’d revisit as the system grows and set explicit revisit points.
Example Use Cases
- Designing a payments processing system with idempotency, retries, and audit logs.
- Architecting a social feed with caching and evolving API surfaces.
- Migrating a monolith to microservices for order fulfillment and inventory.
- Building a real-time analytics pipeline using event queues and streaming.
- Designing a user-profile service with privacy constraints and access control.
