architect-systems

Guide software architecture decisions across patterns, trade-offs, and documentation.

4|1|Updated Dec 30, 2025
One-click install
npx skills add https://github.com/lushly-dev/afd --skill architect-systems
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architect-systems
Source: https://github.com/lushly-dev/afd/tree/main/.claude/skills/architect-systems
Command: npx skills add https://github.com/lushly-dev/afd --skill architect-systems

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the complexity of designing scalable, maintainable software systems by providing guidance on architectural patterns, decision-making frameworks, and best practices for agent-assisted development.

Core Features & Use Cases

  • Architecture Pattern Selection: Guides choices between monoliths, microservices, event-driven architectures, and more.
  • Domain Decomposition: Applies Domain-Driven Design (DDD) principles to identify bounded contexts.
  • ADR Authoring: Facilitates the creation of Architecture Decision Records to document key choices.
  • Agent-Maintainable Design: Promotes structuring systems so AI agents can easily understand, modify, and extend them.
  • Use Case: When starting a new project or refactoring an existing one, use this Skill to explore architectural options, define service boundaries, and document the chosen approach using ADRs.

Quick Start

Use the architect-systems skill to help choose between a monolith and microservices for a new e-commerce platform.

Frequently Asked Questions about architect-systems

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

FAQPage Schema
How do I choose between a monolith and microservices for my system design?▼

System design pattern selection involves evaluating trade-offs between monoliths and microservices based on your scalability and maintainability requirements. This Skill guides architectural pattern choices by comparing modular monoliths, event-driven architectures, and microservices to help you determine the right fit for your project context.

What is the best way to decompose domains using DDD bounded contexts?▼

Domain decomposition using DDD bounded contexts requires identifying core domain boundaries and mapping them to autonomous service limits. This Skill applies Domain-Driven Design principles to help you define bounded contexts, evaluate dependencies, and plan evolutionary architecture migrations effectively.

How do I write an Architecture Decision Record for evaluating architectural trade-offs?▼

Writing an Architecture Decision Record (ADR) involves documenting your architectural decisions, the context surrounding them, and the evaluated trade-offs. This Skill facilitates ADR authoring to capture key choices like adopting CQRS or hexagonal architecture, ensuring design rationale is transparent and maintainable.

Can I use platform engineering principles to structure an agent-maintainable architecture?▼

Platform engineering principles can structure agent-maintainable architecture by creating standardized interfaces and modular boundaries. This Skill promotes designing systems so AI agents can easily understand, modify, and extend codebases by applying ports-and-adapters patterns and fitness functions for evolutionary architecture.

When should I not use event-driven architecture or CQRS in my software architecture?▼

You should avoid event-driven architecture or CQRS when system complexity does not justify the operational overhead of eventual consistency and message routing. This Skill helps evaluate architectural trade-offs, ensuring you only adopt complex patterns like CQRS when scaling demands require them.