home / skills / anthropics / knowledge-work-plugins / system-design

system-design skill

This skill helps you design scalable systems and evaluate architectural decisions with structured guidelines for requirements, data modeling, APIs, and

npx playbooks add skill anthropics/knowledge-work-plugins --skill system-design

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.3 KB

---
name: system-design
description: Design systems, services, and architectures. Trigger with "design a system for", "how should we architect", "system design for", "what's the right architecture for", or when the user needs help with API design, data modeling, or service boundaries.
---

# System 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.

Overview

This skill helps design systems, services, and architectures for web-scale and enterprise applications. It guides you from requirements gathering through high-level architecture to detailed API, data model, and scaling recommendations. Designs include explicit assumptions, trade-offs, and next steps to evolve the system safely.

How this skill works

I inspect your functional and non-functional requirements, constraints (team, timeline, stack), and existing components. I produce a layered design: component diagram and data flow, API contracts, storage and caching choices, queueing/eventing, and error/retry strategies. Each design includes scaling estimates, monitoring needs, and a clear trade-off analysis.

When to use it

You need an end-to-end architecture for a new product or service
You must design APIs, data models, or service boundaries
You want to evaluate trade-offs between technologies or patterns
You need to plan for scale, reliability, or cost constraints
You need concrete implementation guidance for an existing system

Best practices

Start with clear functional and measurable non-functional requirements
Explicitly list assumptions and constraints up front
Prefer simple, well-understood patterns first; optimize where metrics demand
Make APIs and data models backward-compatible and documented
Instrument for observability early: metrics, logs, and distributed traces

Example use cases

Design a multi-tenant SaaS backend with per-tenant isolation and billing
Architect a low-latency public API with rate limiting and caching
Design an event-driven order processing pipeline with retries and DLQ
Migrate a monolith to microservices with data ownership and service contracts
Create a storage strategy for hot, warm, and cold data with cost estimates

FAQ

What deliverables will I get?

A structured design document covering requirements, component diagram (ASCII or described), data flow, API contracts, storage and caching choices, scaling plan, monitoring, assumptions, and trade-offs.

How do you handle unknown constraints or changing requirements?

I call out unknowns explicitly, offer alternative designs for different constraints, and identify which decisions to revisit as the system grows or requirements change.