architecture-patterns

Explain software architecture patterns and guide pattern selection.

20|5|Updated Jan 5, 2026
One-click install
npx skills add https://github.com/miles990/claude-software-skills --skill architecture-patterns-miles990
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/miles990/claude-software-skills/tree/main/software-design/architecture-patterns
Command: npx skills add https://github.com/miles990/claude-software-skills --skill architecture-patterns-miles990

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides guidance on selecting and implementing various software architecture patterns to build scalable, maintainable, and robust systems.

Core Features & Use Cases

  • Pattern Explanations: Understand monolithic, microservices, event-driven, serverless, clean, and hexagonal architectures.
  • Decision Guidance: Use decision trees and comparison tables to choose the right pattern for your project.
  • Anti-Pattern Avoidance: Learn common pitfalls and how to avoid them.
  • Use Case: A startup needs to decide on an initial architecture. This Skill helps them evaluate options like Monolithic vs. Microservices based on team size and scalability needs.

Quick Start

Explain the pros and cons of microservices architecture for a team of 50 developers.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I choose between monolithic and microservices architectures for my project?

Choosing between monolithic and microservices architectures requires evaluating your project requirements, team size, and scalability needs. This Skill provides decision trees and comparison tables to help you select the right software architecture pattern based on these specific factors.

What is hexagonal architecture and when should I use it?

Hexagonal architecture is a software design pattern that isolates business logic from external concerns. You should use it when you need high maintainability and the ability to swap external components easily, which this Skill explains alongside clean and event-driven architectural styles.

How do I evaluate if serverless architecture fits my scalability needs?

Evaluating if serverless architecture fits your scalability needs involves understanding its operational model and constraints. This Skill provides comprehensive explanations of serverless architecture to help you decide if it suits your project requirements and scalability goals.

What are common software architecture anti-patterns and how do I avoid them?

Common software architecture anti-patterns are flawed design choices that reduce system maintainability and scalability. This Skill details these pitfalls and provides decision-making frameworks to help you avoid them when implementing monolithic, microservices, or event-driven systems.

What testing strategies work best for event-driven architecture?

Testing strategies for event-driven architecture focus on validating asynchronous message flows and system integration. This Skill details testing strategies tailored to various architectural styles, ensuring your event-driven or microservices systems remain robust and maintainable.