architecture-designer

Name: architecture-designer
Availability: InStock
Author: jeffallan

Create architecture decision records for scalable cloud-based systems.

10.9k|1.0k|Updated Oct 20, 2025

Search Tags:#architecture #scalability #system design #patterns #ADR #risk #design decisions

Ready to run

npx skills add https://github.com/Jeffallan/claude-skills --skill architecture-designer

💬 Prompt for ChatGPT / Claude Chat▼

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.