architecture-designer

Create architecture decision records for scalable cloud-based systems.

10.9k|1.0k|Updated Oct 20, 2025
One-click install
npx skills add https://github.com/Jeffallan/claude-skills --skill architecture-designer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-designer
Source: https://github.com/Jeffallan/claude-skills/tree/main/skills/architecture-designer
Command: npx skills add https://github.com/Jeffallan/claude-skills --skill architecture-designer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill guides architecture decisions, ADRs, and system design patterns for scalable platforms.

Core Features & Use Cases

  • Architecture Patterns: Monolith, modular monolith, microservices, event-driven.
  • ADR Documentation: Architecture Decision Records for decisions.
  • System Design: High-level design templates and diagrams.
  • NFR & Trade-offs: Non-functional requirements and risk mitigation.

Quick Start

Draft an ADR for moving from a monolith to microservices with a phased approach.

Frequently Asked Questions about architecture-designer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I document architecture decisions for a scalable system?

Architecture Decision Records (ADRs) document the rationale, trade-offs, and consequences of key system design choices. ADRs capture functional requirements, non-functional requirements, and risk mitigation for decisions like moving from monolith to microservices, ensuring teams align on design direction and constraints.

What architecture patterns work best for scalable distributed systems?

Common patterns for scalability include monolith, modular monolith, microservices, and event-driven architectures. Each pattern trades off complexity, deployment independence, and operational overhead differently; selecting the right one depends on your system's growth trajectory, team size, and non-functional requirements like latency and fault isolation.

How do I evaluate trade-offs when redesigning system architecture?

Evaluate trade-offs by capturing non-functional requirements (NFRs), assessing scalability impact, identifying risks, and documenting alternatives in Architecture Decision Records. This structured approach ensures decisions balance performance, reliability, maintainability, and operational complexity across cloud-based distributed environments.

Can I use ADRs to plan a migration from monolithic to microservices?

Yes. ADRs document the phased migration strategy, justify the architectural shift, capture trade-offs like increased complexity and operational overhead, and record risk mitigation for each stage. This creates a decision trail that aligns stakeholders and guides incremental architecture evolution.

What should I include when creating a high-level system design?

High-level system design should include architecture pattern selection, non-functional requirements (scalability, availability, latency), identified risks, trade-off analysis, and decision rationale. Templates and ADR frameworks ensure consistent documentation and make design reasoning explicit for reviews and future modifications.

When do I need to document architecture decisions formally?

Formal ADR documentation is critical for decisions affecting scalability, deployment strategy, technology choices, and system structure—especially in distributed systems. ADRs prevent decision bottlenecks, ensure non-functional requirements are captured, and provide decision context for architecture reviews and team onboarding.