Loading...
Loading...
Found 20 Skills
Hexagonal (ports and adapters) architecture patterns for TypeScript. Use when implementing ports, adapters, dependency inversion, or domain isolation. Only applies to projects that explicitly use hexagonal architecture. Do NOT use for projects without ports/adapters structure.
Design, implement, and refactor Ports & Adapters systems with clear domain boundaries, dependency inversion, and testable use-case orchestration across TypeScript, Java, Kotlin, and Go services.
Provides comprehensive guidance for hexagonal architecture including ports and adapters, domain isolation, and dependency inversion. Use when the user asks about hexagonal architecture, needs to implement ports and adapters pattern, or structure applications with hexagonal architecture.
Explain and apply Freetool's OpenFGA integration using onion/hexagonal architecture boundaries, including exactly where authorization logic belongs and where it must not be implemented. Use when reviewing auth design, adding permissions, changing OpenFGA tuple writes/checks, or teaching team conventions with real code samples.
Hexagonal architecture layering for Java services with strict boundaries. Trigger: When structuring Java apps by Domain/Application/Infrastructure, or refactoring toward clean architecture.
Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when architecting complex backend systems or refactoring existing applications for better maintainability.
Keep a system's business logic independent of the technology it talks to, by reasoning about which way dependencies point across a hexagonal / ports-and-adapters / clean-architecture boundary. A system holds three kinds of code — its reason to exist (the business logic), its connections to the outside world, and how it's run (the wiring and entrypoint) — so the question is never "which folder" but "is this the reason, a connection, or how it's run, and what may it depend on?" Use it to scaffold a new system, place a feature, integration, or entrypoint, review how it's shaped, or write an ADR about the layout — and whenever a dependency points the wrong way or you're unsure where something belongs. Language-/framework-agnostic: the kinds map onto whatever names a project uses (app/infra/run, domain/adapters/cmd). Reach for it even when the user never says "hexagonal": "where should this go", "scaffold it ports-and-adapters", "review against hexagonal principles", "which layer owns this" are all signals.
Clean Architecture + DDD + Hexagonal - Atoll Tourisme. Use when designing architecture or reviewing code structure.
Use when structuring or refactoring Convex codebases with Domain-Driven Design boundaries, repository abstractions, adapters for external APIs, and transaction-safe workflows.
Apply Clean Architecture + DDD + Hexagonal patterns to backend services. Use when designing APIs, microservices, domain models, aggregates, repositories, bounded contexts, or scalable backend structure. Triggers on DDD, Clean Architecture, Hexagonal, ports and adapters, entities, value objects, domain events, CQRS, event sourcing, repository pattern, use cases, onion architecture, outbox pattern, aggregate root, anti-corruption layer. Language-agnostic (Go, Rust, Python, TypeScript, Java, C#).
Module organization patterns including ports and adapters (hexagonal), module communication, and data isolation. Use when structuring modular monoliths, defining module boundaries, setting up inter-module communication, or isolating database contexts. Includes MediatR patterns for internal events.
Enterprise-level Go architecture patterns including clean architecture, hexagonal architecture, DDD, and production-ready application structure.