spec:architect

Design domain-driven architectures with hexagonal patterns and bounded contexts.

39|4|Updated Jan 11, 2026
One-click install
npx skills add https://github.com/martinffx/atelier --skill spec-architect-martinffx
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: spec:architect
Source: https://github.com/martinffx/atelier/tree/main/skills/spec%3Aarchitect
Command: npx skills add https://github.com/martinffx/atelier --skill spec-architect-martinffx

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Domain-driven design and hexagonal architecture provide a structured blueprint to manage complexity by separating business rules from I/O concerns, aligning domain language with implementation.

Core Features & Use Cases

  • Domain modeling guidance: emphasizes aggregates, entities, value objects, and domain events to enforce invariants.
  • Architectural patterns: promotes functional core versus IO edge, dependency inversion, and bounded contexts for clear boundaries.
  • Reference materials & patterns: includes curated patterns and references (DDD patterns, data modeling, API design) to accelerate design decisions.

Quick Start

Compose an architectural plan for a new feature that isolates core domain logic from external integrations using DDD and hexagonal patterns.

Frequently Asked Questions about spec:architect

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

FAQPage Schema
What is domain-driven design and how does hexagonal architecture help manage software complexity?

Domain-driven design aligns domain language with implementation, while hexagonal architecture manages complexity by separating business rules from I/O concerns using a functional core and effectful edge.

How do I design a new feature using bounded contexts and aggregates?

Design new features by isolating core domain logic from external integrations, using aggregates, entities, value objects, and domain events to enforce invariants and clarify component responsibilities across bounded contexts.

How does the functional core and effectful edge pattern enforce separation of concerns?

The functional core and effectful edge pattern enforces separation of concerns by isolating pure domain logic from external I/O operations, utilizing dependency inversion to keep business rules independent of infrastructure.

When should I use domain events and bounded contexts for task decomposition?

Use domain events and bounded contexts during task decomposition to establish clear boundaries between system components, align domain language with implementation, and manage complexity across distinct business areas.

Can I use this approach to clarify component responsibilities across different contexts?

Yes, this approach clarifies component responsibilities by defining bounded contexts and applying hexagonal patterns, ensuring clear boundaries and separation of concerns across integrated business domains.

What architectural patterns are recommended for isolating core domain logic from external integrations?

Recommended architectural patterns include dependency inversion, functional core versus IO edge separation, and bounded contexts, alongside curated DDD, data modeling, and API design references to accelerate decisions.