hexagonal-advisor

Hexagonal architecture violations occur when domain logic couples to infrastructure—database queries in business logic, HTTP calls in services, or adapters importing domain code. Analyze your codebase for dependency direction: domain should depend on ports (interfaces), never adapters (implementations). This Skill scans for leaks and recommends ports-and-adapters refactoring to restore clean boundaries.

Ports are domain-facing interfaces that define what external capabilities your business logic needs; adapters implement those ports to connect to real infrastructure like databases or HTTP clients. In Rust, ports are traits, adapters are concrete implementations. Separating them ensures domain logic remains testable and independent of technology choices.

Define repository and service ports as traits in your domain, then implement them as adapters in infrastructure code. This decoupling lets you inject mock adapters during testing without touching domain logic. This Skill provides templates and refactoring guidance to restructure existing code into clean ports-and-adapters patterns for Rust services.

Yes. Hexagonal architecture fits services, repositories, and domain logic boundaries in any stage of development. This Skill analyzes your current code for architecture problems—business logic mixed with database access, infrastructure leaking into domain—and provides concrete refactoring steps to incrementally adopt ports-and-adapters separation without rewriting from scratch.

Tight coupling makes testing expensive, forces you to mock external systems, and locks your domain to specific technologies. It violates hexagonal architecture's core principle: domain logic should depend inward on ports, never outward on infrastructure. This Skill detects these violations and recommends adapter-based separation to restore testability and independence.

No. Hexagonal architecture works incrementally: identify the highest-impact boundary violations—where business logic couples most tightly to infrastructure—and refactor those first. This Skill prioritizes recommendations by dependency-direction risk, so you can improve architecture in focused, manageable steps.