hexagonal-architecture

Design and implement Ports & Adapters systems in TypeScript, Java, Kotlin, and Go.

2|Updated Apr 14, 2026
One-click install
npx skills add https://github.com/klu-dev/porting-ecc-to-vscode --skill hexagonal-architecture-klu-dev
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: hexagonal-architecture
Source: https://github.com/klu-dev/porting-ecc-to-vscode/tree/main/.github/skills/hexagonal-architecture
Command: npx skills add https://github.com/klu-dev/porting-ecc-to-vscode --skill hexagonal-architecture-klu-dev

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill addresses the challenge of creating maintainable and testable software architecture by guiding the implementation of Ports & Adapters, a hexagonal architecture pattern.

Core Features & Use Cases

  • Domain-Driven Design: Ensures business logic remains clean and decoupled from external dependencies.
  • Testability: Facilitates unit testing of domain logic in isolation from infrastructure.
  • Refactoring: Helps refactor existing codebases to improve maintainability and scalability.

Quick Start

Implement a hexagonal architecture for your service by defining domain models, use cases, and ports, then implement adapters for each port.

Frequently Asked Questions about hexagonal-architecture

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

FAQPage Schema
How do I separate business logic from infrastructure in TypeScript or Java?

To separate business logic from infrastructure, implement a hexagonal architecture using Ports & Adapters. This pattern keeps your domain logic decoupled from external dependencies, ensuring a clean separation of concerns.

What is the best way to refactor a monolithic codebase for better testability?

The best way to refactor for testability is applying the hexagonal architecture pattern. By defining domain models, use cases, and ports, you can unit test your domain logic in complete isolation from infrastructure.

How does hexagonal architecture work with domain-driven design principles?

Hexagonal architecture works with domain-driven design by centering the system around domain models and use cases. External dependencies interact through defined ports, ensuring the business logic remains clean and decoupled.

Can I use Ports & Adapters for a Go or Kotlin service?

Yes, you can use Ports & Adapters for Go or Kotlin services. This Skill focuses on these languages alongside TypeScript and Java, guiding the implementation of domain-centric design for clean, testable software architecture.

How do I implement hexagonal architecture step by step?

To implement hexagonal architecture, start by defining your domain models and use cases. Next, define the required ports, then implement the specific adapters for each port to handle external dependencies.

When should I not use hexagonal architecture?

You should not use hexagonal architecture if you lack familiarity with domain-driven design principles. It requires knowledge of decoupling domain logic from infrastructure, which may introduce unnecessary complexity for simple services.