software-architecture

Design Clean Architecture and DDD blueprints with dependency rules and bounded contexts.

Updated Apr 16, 2026
One-click install
npx skills add https://github.com/duylinhdang1998/claude-template-agent --skill software-architecture-duylinhdang1998
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-architecture
Source: https://github.com/duylinhdang1998/claude-template-agent/tree/main/plugins/vfm-agent-company/skills/software-architecture
Command: npx skills add https://github.com/duylinhdang1998/claude-template-agent --skill software-architecture-duylinhdang1998

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Large or long-lived codebases often become tightly coupled, hard to test, and expensive to change; this Skill provides structured guidance to separate concerns, enforce boundaries, and make systems maintainable and evolvable. It helps teams avoid common anti-patterns like anemic domains, god objects, and leaky abstractions while prioritizing testability and clear module responsibilities.

Core Features & Use Cases

  • Layered Architecture Guidance: Recommend Clean Architecture or Hexagonal layouts and describe dependency rules and layer responsibilities.
  • Domain Modeling with DDD: Identify bounded contexts, aggregates, entities, value objects, domain events, and repository interfaces.
  • SOLID & Pattern Enforcement: Advise on applying SOLID principles and selecting creational, structural, and behavioral patterns (Factory, Repository, Adapter, Strategy, Observer, etc.).
  • Folder Blueprints & Composition Root: Provide concrete folder structures, module names, and a composition root for dependency injection and wiring.
  • Refactoring & Legacy Strategy: Suggest Strangler Fig approaches, incremental extract techniques, and CQRS/event-driven transitions for microservices or monoliths.
  • Use Cases: Designing a new service with DDD, refactoring legacy systems, planning microservice boundaries, or implementing testable business workflows.

Quick Start

Use the software-architecture skill to generate a Clean Architecture folder blueprint and DDD bounded context plan for an e-commerce order service.

Frequently Asked Questions about software-architecture

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

FAQPage Schema
How do I design a clean architecture folder structure for a new service?

To design clean architecture, this Skill generates concrete folder blueprints, module names, and a composition root for dependency injection, defining layer responsibilities and dependency rules to ensure separation of concerns and testability.

What is the best way to identify bounded contexts for microservices?

Identifying bounded contexts for microservices involves domain modeling with DDD principles, which this Skill uses to define aggregates, entities, value objects, domain events, and repository interfaces to establish clear module boundaries.

How do I refactor a legacy monolith incrementally?

Refactoring a legacy monolith incrementally uses the Strangler Fig approach, and this Skill suggests incremental extract techniques and CQRS or event-driven transitions to decouple tightly coupled codebases into maintainable, evolvable systems.

When should I apply SOLID principles and design patterns in software architecture?

Apply SOLID principles and design patterns in software architecture when avoiding anti-patterns like anemic domains, god objects, and leaky abstractions; this Skill advises on selecting creational, structural, and behavioral patterns like Factory, Repository, and Adapter.

How does DDD aggregate design work for complex systems?

DDD aggregate design works by grouping entities and value objects into transactional boundaries, and this Skill produces aggregate definitions and interface boundaries to enforce clear module responsibilities and ensure testability.

Can I use this approach to plan event-driven transitions for microservices?

Yes, you can use this approach to plan event-driven transitions for microservices, as the Skill provides structured guidance for CQRS and event-driven architecture, recommending incremental extract techniques and defining bounded contexts.