architecture-patterns
This skill covers foundational architectural approaches for structuring software systems at scale. It walks through monolithic, microservices, event-driven, serverless, clean, and domain-driven architectures—each with use cases, trade-offs, and implementation guidance. A decision tree helps you pick the right pattern based on team size, deployment autonomy, audit requirements, and load variability.
Architecture Patterns helps you choose the right structural approach—from monoliths to microservices to event-driven systems—based on your team size, scalability needs, and domain complexity.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-01-20
Architecture Patterns helps you choose the right structural approach—from monoliths to microservices to event-driven systems—based on your team size, scalability needs, and domain complexity. This skill covers foundational architectural approaches for structuring software systems at scale. It walks through monolithic, microservices, event-driven, serverless, clean, and domain-driven architectures—each with use cases, trade-offs, and implementation guidance. A decision tree helps you pick the right pattern based on team size, deployment autonomy, audit requirements, and load variability.
Use it when
- architecture-patterns includes a decision tree to help you pick the right pattern based on team size, deployment autonomy.
- architecture-patterns explains when to adopt microservices architecture versus monolithic approaches.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Install
miles990/claude-software-skills/architecture-patterns · repository language: TypeScript
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
What software architecture patterns are explained in architecture-patterns?
architecture-patterns covers foundational architectural approaches for structuring software systems at scale, including monolithic, microservices, event-driven, serverless, clean, and domain-driven architectures. Each pattern includes use cases, trade-offs, and implementation guidance to help you understand when and how to apply them.
How do I choose the right architecture for my project?
architecture-patterns includes a decision tree to help you pick the right pattern based on team size, deployment autonomy, audit requirements, and load variability. The skill walks through the trade-offs of each approach so you can match your system's constraints and goals to the most suitable architecture.
When should I use microservices vs. monolith?
architecture-patterns explains when to adopt microservices architecture versus monolithic approaches. Microservices suit scenarios requiring independent deployment, team autonomy, and varied scaling needs, while monoliths work better for smaller teams, simpler domains, and tightly coupled features. The skill helps you evaluate your specific constraints.
What is the strangler fig pattern for legacy migration?
architecture-patterns covers the strangler fig pattern as a modular approach to migrating legacy systems. This pattern lets you incrementally replace pieces of an old system with new code without a risky big-bang rewrite, reducing migration risk and allowing gradual adoption of modern architecture.
How do clean architecture and domain-driven design principles work?
architecture-patterns guides you through designing system structure using clean architecture layers with dependency inversion and domain-driven design (DDD) principles. These approaches emphasize isolating business logic from infrastructure, making systems more testable, maintainable, and aligned with domain complexity.
What patterns help design scalable systems and boost team productivity?
architecture-patterns compares architecture patterns for scalability and team productivity, covering event-driven, serverless, hexagonal, and modular monolith structures. It explains how each pattern affects deployment speed, system responsiveness, team autonomy, and operational complexity so you can optimize for your priorities.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Architecture Patterns
Overview
Architecture patterns provide proven solutions for structuring software systems. Choosing the right architecture is crucial for scalability, maintainability, and team productivity.
Patterns
Monolithic Architecture
Description: Single deployable unit containing all application functionality.
Key Features: - Simple deployment and development - Shared database and memory - Straightforward debugging
Use Cases: - MVPs and startups - Small teams (< 10 developers) - Simple domain logic
Best Practices: ``` src/ ├── modules/ # Feature-based organization │ ├── users/ │ ├── orders/ │ └── products/ ├──
(truncated - see the full file via the links below)
File tree — 1 file
software-design/architecture-patterns/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Learn which software architecture pattern fits my project needs”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master the decision to decompose systems into independent services and the patterns that keep them reliable. Covers bounded contexts, strangler fig extraction, synchronous vs. asynchronous communication, circuit breakers, saga patterns, and event sourcing—helping you avoid distributed monoliths and operational chaos.
Master the fundamentals of building distributed systems through microservices, from domain-driven design and service boundaries to synchronous and asynchronous communication patterns. Explore data consistency strategies, API gateway implementation, and service discovery to architect scalable, independently deployable systems.
Make informed architecture decisions for new systems or major refactors. This skill guides you through pattern selection, scalability design, resilience strategies, and data consistency models—with concrete technology recommendations and tradeoff analysis. Covers decomposition, service boundaries, observability planning, and migration from legacy systems.
Architecture Selection helps teams pick the best system design by evaluating patterns against team size, domain complexity, scaling needs, and operational maturity. It scores candidates using weighted criteria, documents trade-offs, and provides migration paths—avoiding resume-driven choices and premature optimization. Use it to design new systems, plan migrations, or review existing architectures.
Guides you through selecting the right architecture pattern—clean, hexagonal, feature-based, or vertical slice—based on team size and domain complexity. Covers folder structure, dependency inversion, module boundaries, and SOLID principles at application scale. Diagnoses architectural problems like fat controllers and circular dependencies.
This skill guides architects through building cloud-native microservices systems from the ground up. It covers domain-driven service decomposition, communication pattern selection, data ownership strategies, resilience implementation, and observability setup—with concrete code examples for correlation IDs, circuit breakers, sagas, and Kubernetes probes.
More skills game-development (MIT) · System Design (unlicensed) · project-structure (MIT) · testing-strategies (MIT) · Requirements Analysis (unlicensed) · architecture-patterns (MIT)