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.