This skill should be used when designing systems, evaluating architectures, making technology decisions, or planning for scale. Provides technology selection frameworks, scalability planning, and architectural tradeoff analysis.
Designs scalable systems by evaluating architectural tradeoffs and providing technology selection frameworks.
npx claudepluginhub outfitter-dev/outfitterThis skill inherits all available tools. When active, it can use any tool Claude has access to.
references/adr-template.mdreferences/common-patterns.mdreferences/design-patterns.mdreferences/implementation-guidance.mdreferences/questions-checklist.mdreferences/rust-architecture.mdreferences/scalability.mdreferences/technology-selection.mdDesign question → options with tradeoffs → documented decision.
<when_to_use>
NOT for: trivial tech choices, premature optimization, undocumented requirements
</when_to_use>
<stages>Load the maintain-tasks skill for stage tracking. Stages advance only, never regress.
| Stage | Trigger | activeForm |
|---|---|---|
| Discovery | Session start | "Gathering requirements" |
| Codebase Analysis | Requirements clear | "Analyzing codebase" |
| Constraint Evaluation | Codebase understood | "Evaluating constraints" |
| Solution Design | Constraints mapped | "Designing solutions" |
| Documentation | Design selected | "Documenting architecture" |
Situational (insert before Documentation when triggered):
Edge cases:
Task format:
- Discovery { problem domain }
- Analyze { codebase area }
- Evaluate { constraint type }
- Design { solution approach }
- Document { decision type }
Workflow:
in_progresscompleted, add next in_progressFavor battle-tested over bleeding-edge without strong justification.
Checklist:
Red flags: "Early adopters" without time budget, "Written in X" without benchmarks, "Everyone's talking" without case studies.
Each abstraction must provide 10x value.
Questions:
Small, focused modules with clear contracts, single responsibilities.
Checklist:
No system ships without metrics, tracing, alerting.
Required every service:
Use contemporary proven patterns for greenfield, respect legacy constraints.
Patterns (2025):
Legacy respect: document why legacy exists, plan incremental migration, don't rewrite what works.
Design for change with clear upgrade paths.
Practices:
<technology_selection_summary>
Load technology-selection.md for detailed guidance.
Database: Match data model to use case. PostgreSQL for ACID + complex queries. DynamoDB for flexibility + horizontal scaling. Redis for caching + pub/sub.
Framework (TS): Hono for modern/serverless, Express for proven ecosystem, Fastify for speed, NestJS for enterprise.
Framework (Rust): Axum for type-safe modern, Actix-web for raw performance.
Frontend: React + TanStack Router for complex apps, Solid for perf-critical, Next.js for SSR/SSG.
Infrastructure: Serverless for low-traffic/prototypes, K8s/ECS for multi-service at scale, PaaS for MVPs.
Selection criteria: team expertise, performance needs, ecosystem, type safety, deployment target.
</technology_selection_summary>
<design_patterns_summary>
Load design-patterns.md for detailed guidance.
Service Decomposition
Monolith first. Extract when hitting specific pain:
Microservices: yes for 10+ engineers, clear domains, independent scaling. No for small teams, unclear domains.
Communication
| Pattern | Use when | Tradeoffs |
|---|---|---|
| Sync (REST, gRPC) | Immediate response needed | Tight coupling, cascading failures |
| Async (queues, streams) | Eventual consistency OK | Complexity, ordering challenges |
| Event-driven | Decoupling, audit trail | Event versioning, consistency |
Data Management
</design_patterns_summary>
<scalability_summary>
Load scalability.md for detailed guidance.
Key Metrics: Latency (p50/p95/p99), throughput (RPS), utilization (CPU/mem/net/disk), error rates, saturation (queues, pools).
Capacity Planning: Baseline → load test → find limits → model growth → plan 30-50% headroom.
Bottleneck Solutions:
| Resource | Solutions |
|---|---|
| Database | Indexing, read replicas, caching, sharding |
| CPU | Horizontal scale, algorithm optimization, async |
| Memory | Profiling, streaming, data structure optimization |
| Network | Compression, CDN, HTTP/2, gRPC |
| I/O | SSD, batching, async I/O, caching |
Scaling Strategies: Vertical (simple, limited), horizontal (stateless required), caching layers (L1/L2/L3), database scaling (replicas, sharding, pooling).
</scalability_summary>
<rust_summary>
Load rust-architecture.md for detailed guidance.
Choose Rust when: Performance-critical, resource-constrained, memory safety critical, concurrent processing.
Skip Rust when: Prototype/MVP, small team without experience, standard CRUD, missing ecosystem libs.
Stack: tokio (runtime), axum/actix-web (framework), sqlx/diesel (database), serde (serialization), tracing (observability), thiserror/anyhow (errors).
vs TypeScript: Rust is 2-10x faster, 5-10x lower memory, compile-time bug detection, no GC. TS has faster iteration, massive ecosystem, easier hiring.
</rust_summary>
<common_patterns_summary>
Load common-patterns.md for detailed guidance.
| Pattern | Purpose |
|---|---|
| API Gateway | Single entry, routing, auth, rate limiting |
| BFF | Per-client backends with optimized data shapes |
| Circuit Breaker | Fail fast when downstream unhealthy |
| Saga | Distributed transactions across services |
| Strangler Fig | Gradual legacy migration via proxy |
</common_patterns_summary>
<implementation_summary>
Load implementation-guidance.md for detailed guidance.
Phased Delivery:
Critical Path: Identify blocking dependencies, parallel workstreams, resource constraints, risk areas, decision points.
Observability: Metrics (RED), logging (structured + correlation IDs), tracing (OpenTelemetry), alerting (SLO-based + runbooks).
</implementation_summary>
<adr_summary>
Load adr-template.md for the full template.
ADR structure:
</adr_summary>
<questions_summary>
Load questions-checklist.md for the full checklist.
Requirements: Core workflows, data storage, integrations, critical vs nice-to-have.
Non-functional: Users (now + 1-2 yrs), latency targets, availability (99.9%? 99.99%?), consistency, compliance.
Constraints: Existing systems, current tech, team expertise, deployment env, budget, timeline, acceptable debt.
Technology Selection: Why this over alternatives? Production experience? Operational complexity? Lock-in risk? Hiring?
Risk: Blast radius? Rollback strategy? Detection? Contingency? Assumptions? Cost of being wrong?
</questions_summary>
<workflow>Use EnterPlanMode when presenting options — enables keyboard navigation.
Structure:
After user choice:
Before documenting:
At Documentation stage:
ALWAYS:
NEVER:
Core:
Deep Dives:
Activates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use for discovering, retrieving, and improving prompts.
Search, retrieve, and install Agent Skills from the prompts.chat registry using MCP tools. Use when the user asks to find skills, browse skill catalogs, install a skill for Claude, or extend Claude's capabilities with reusable AI agent components.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.