software-architecture-design
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.
Software Architecture Design helps you choose between monolith, microservices, serverless, and event-driven patterns for system-level decisions.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-13
Software Architecture Design helps you choose between monolith, microservices, serverless, and event-driven patterns for system-level decisions. 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.
Use it when
- Software-architecture-design covers four primary patterns: monolith (vertical scaling limits).
- Software-architecture-design guides decomposition through domain-driven design and the strangler fig pattern.
Verify before relying
Read SKILL.md below before installing (14 files). Open directory: indexed for reading, not audited.
Install
vasilyu1983/AI-Agents-public/software-architecture-design · repository language: Python
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
How do I choose between monolith vs microservices which should I choose?
Software-architecture-design helps you evaluate this decision by weighing team size, deployment frequency, and scaling needs. Monoliths suit small teams and simple domains; microservices fit organizations needing independent deployment and scaling. The skill guides you through tradeoff analysis—monoliths offer simpler operations but tight coupling, while microservices enable autonomy but add distributed system complexity. Consider your current constraints before committing.
What system architecture patterns work best for scaling?
Software-architecture-design covers four primary patterns: monolith (vertical scaling limits), microservices (horizontal scaling with service independence), serverless (auto-scaling managed by provider), and event-driven (decoupled via async messaging). Each pattern trades operational complexity against scalability ceiling. The skill helps you match patterns to your traffic profile, team structure, and tolerance for distributed system challenges like eventual consistency and observability.
How do I decompose a monolith into microservices?
Software-architecture-design guides decomposition through domain-driven design and the strangler fig pattern. Start by identifying service boundaries aligned to business capabilities, not technical layers. The skill covers incremental migration strategies—running old and new systems in parallel, gradually routing traffic to new services. You'll learn how to handle data consistency, define APIs, and manage team ownership during the transition without halting feature delivery.
What role do architecture decision records play in system design?
Software-architecture-design emphasizes ADRs as living documentation of why architectural choices were made, not just what they are. ADRs capture context, alternatives considered, and tradeoffs—critical when teams scale or systems evolve. The skill teaches you to document decisions like service boundaries, communication patterns, and consistency models so future maintainers understand constraints and can revisit choices when conditions change.
How should I plan data consistency and inter-service communication?
Software-architecture-design addresses consistency models (strong vs eventual), synchronous patterns (REST, gRPC), and asynchronous approaches (event streams, message queues). For distributed systems, you'll learn when to accept eventual consistency, how to implement saga patterns for transactions, and strategies for observability across service calls. The skill balances consistency guarantees against latency and availability—no one-size-fits-all solution exists.
How do I structure a large system for resilience and team ownership?
Software-architecture-design teaches you to align system boundaries with team structure and business domains. Use circuit breakers, timeouts, and bulkheads to isolate failures. Plan observability—logging, metrics, tracing—across services from the start. The skill covers service mesh patterns, API gateways, and how to define clear contracts between teams. Resilience emerges from both technical patterns and organizational clarity about who owns what.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Software Architecture Design — Quick Reference
Use this skill for system-level design decisions rather than implementation details within a single service or component.
Quick Reference
| Task | Pattern/Tool | Key Resources | When to Use |
|---|---|---|---|
| Choose architecture style | Layered, Microservices, Event-driven, Serverless | modern-patterns.md | Greenfield projects, major refactors |
| Design for scale | Load balancing, Caching, Sharding, Read replicas | scalability-reliability-guide.md | High-traffic systems, performance goals |
| Ensure resilience | Circuit breakers, Retries, Bulkheads, Graceful degradation | scalability-reliability-guide.md | Distributed systems, external dependencies |
| Document decisions | Architecture Decision Record (ADR) |
(truncated - see the full file via the links below)
File tree — 14 files
frameworks/shared-skills/skills/software-architecture-design/SKILL.md
frameworks/shared-skills/skills/software-architecture-design/assets/operations/scalability-checklist.md
frameworks/shared-skills/skills/software-architecture-design/assets/patterns/event-driven-template.md
frameworks/shared-skills/skills/software-architecture-design/assets/patterns/microservices-template.md
frameworks/shared-skills/skills/software-architecture-design/assets/planning/adr-template.md
frameworks/shared-skills/skills/software-architecture-design/assets/planning/architecture-blueprint.md
frameworks/shared-skills/skills/software-architecture-design/data/sources.json
frameworks/shared-skills/skills/software-architecture-design/references/api-gateway-service-mesh.md
frameworks/shared-skills/skills/software-architecture-design/references/architecture-trends-2026.md
frameworks/shared-skills/skills/software-architecture-design/references/data-architecture-patterns.md
frameworks/shared-skills/skills/software-architecture-design/references/migration-modernization-guide.md
frameworks/shared-skills/skills/software-architecture-design/references/modern-patterns.md
frameworks/shared-skills/skills/software-architecture-design/references/operational-playbook.md
frameworks/shared-skills/skills/software-architecture-design/references/scalability-reliability-guide.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 › “Choose an architecture pattern (monolith, microservices, serverless, event-driven) for a new or refactored system”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
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.
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.
Build APIs across REST, GraphQL, gRPC, and tRPC styles with contract-first design, RFC 9457 error models, and modern best practices. Covers OpenAPI specs, versioning strategies, authentication/authorization, rate limiting, pagination, and observability patterns for public and internal services.
Architecture Designer guides you through system design from requirements to documented decisions. It creates architecture diagrams, evaluates technology trade-offs, and produces Architecture Decision Records for key choices. Use it to structure microservices, plan scalability, and validate designs with stakeholders.
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.
Master the core patterns for building distributed architectures, from decomposing monoliths to implementing resilient inter-service communication. Covers service boundaries organized by business capability, synchronous and asynchronous messaging, and failure-handling techniques like circuit breakers and bulkheads.
More skills microservices-patterns (MIT) · architecture (MIT)