System Architecture Skill

System Architecture

Design scalable, maintainable system architectures.

When to Use

Major architectural decisions
System design discussions
Evaluating trade-offs
Planning large refactors
Reviewing system structure

Design Process

Understand - Clarify requirements and constraints
Identify - Define components and boundaries
Design - Create architecture with trade-offs
Validate - Check against requirements
Document - Record decisions and rationale

Architecture Patterns

Layered Architecture

┌─────────────────────────────┐
│      Presentation Layer     │  UI, API endpoints
├─────────────────────────────┤
│       Business Layer        │  Domain logic, services
├─────────────────────────────┤
│      Persistence Layer      │  Repositories, DAOs
├─────────────────────────────┤
│        Data Layer           │  Database, cache
└─────────────────────────────┘

Microservices

┌─────────┐  ┌─────────┐  ┌─────────┐
│ User    │  │ Order   │  │ Payment │
│ Service │  │ Service │  │ Service │
└────┬────┘  └────┬────┘  └────┬────┘
     │            │            │
     └────────────┼────────────┘
                  │
           ┌──────┴──────┐
           │ Message Bus │
           └─────────────┘

Event-Driven

Producer → Event Bus → Consumer(s)
              │
              ├→ Service A
              ├→ Service B
              └→ Analytics

Decision Framework

Trade-off Analysis

| Aspect | Option A | Option B | | -------------- | -------- | ---------- | | Complexity | Low | High | | Scalability | Limited | Horizontal | | Cost | $ | $$$ | | Time to market | Fast | Slow | | Maintenance | Easy | Complex |

ADR Template

# ADR-001: [Decision Title]

## Status

Accepted | Proposed | Deprecated

## Context

[Why we need to make this decision]

## Decision

[What we decided]

## Consequences

### Positive

- [Benefit 1]

### Negative

- [Trade-off 1]

### Risks

- [Risk 1]

Key Principles

Separation of Concerns - Each component has one responsibility
Loose Coupling - Minimize dependencies between components
High Cohesion - Related functionality grouped together
YAGNI - Don't build for hypothetical requirements
Fail Fast - Detect and report errors immediately

Scalability Checklist

[ ] Stateless services (session in Redis/DB)
[ ] Horizontal scaling capability
[ ] Database read replicas
[ ] Caching layer (Redis, CDN)
[ ] Async processing for heavy tasks
[ ] Rate limiting and circuit breakers

Examples

Input: "Design a notification system" Action: Define channels, queue architecture, delivery guarantees, scaling strategy

Input: "Should we use microservices?" Action: Analyze team size, complexity, scaling needs, recommend with trade-offs

Agent Skills: System Architecture

Install this agent skill to your local

Skill Files