architecture-patterns

Design and refactor backend systems using Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.

Updated May 16, 2026
One-click install
npx skills add https://github.com/p-o-ke-nae/pokemondamagecalculatorforstory --skill architecture-patterns-p-o-ke-nae
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/p-o-ke-nae/pokemondamagecalculatorforstory/tree/main/.github/skills/architecture-patterns
Command: npx skills add https://github.com/p-o-ke-nae/pokemondamagecalculatorforstory --skill architecture-patterns-p-o-ke-nae

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you design or refactor backend systems using proven architecture patterns so the codebase stays maintainable, testable, and scalable instead of becoming tightly coupled and hard to evolve.

Core Features & Use Cases

  • Clean Architecture Guidance: Organize entities, use cases, adapters, and infrastructure with inward-pointing dependencies.
  • Hexagonal Architecture Guidance: Define ports and adapters so core business logic stays isolated from databases, APIs, and external services.
  • Domain-Driven Design Support: Model bounded contexts, aggregates, entities, value objects, repositories, and domain events for complex domains.
  • Use Case: Ideal when planning a greenfield backend, untangling a monolith, improving testability, or preparing a system for safer long-term growth.

Quick Start

Ask for a backend architecture plan or refactor strategy that applies Clean Architecture, Hexagonal Architecture, or Domain-Driven Design to your application.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I refactor a legacy monolith to improve backend testability?

To improve backend testability, refactor legacy monoliths by enforcing inward dependency flow and isolating domain logic using repository abstractions. Applying Clean Architecture and Hexagonal Architecture principles untangles tightly coupled code and isolates core business rules from databases and external services.

What is the best way to structure a new backend system for long-term scalability?

The best way to structure scalable backend systems is applying Domain-Driven Design to model bounded contexts and aggregates, combined with Hexagonal Architecture ports and adapters. This isolates core business logic, ensuring safer long-term growth and maintainable infrastructure evolution.

How does Hexagonal Architecture isolate domain logic from external services?

Hexagonal Architecture isolates domain logic by defining ports and adapters, ensuring core business rules remain independent of databases, APIs, and external services. This enforces an inward dependency flow where infrastructure components interact with the domain only through specified adapter interfaces.

When do I need Domain-Driven Design bounded contexts for microservice decomposition?

You need Domain-Driven Design bounded contexts for microservice decomposition when untangling complex monolithic domains into isolated services. Modeling bounded contexts, aggregates, and domain events defines clear service boundaries, ensuring isolated domain logic and safer system scaling.

Can I use Clean Architecture with thin controllers and repository abstractions?

Yes, Clean Architecture uses thin controllers and repository abstractions to organize entities, use cases, and adapters. This enforces inward-pointing dependencies, ensuring infrastructure concerns remain separated from isolated domain logic and improving overall system maintainability.