architecture-patterns
Implement Backend Architecture Patterns
Also available from: Barnhardt-Enterprises-Inc,AdamManuel-dev
Building maintainable backend systems requires proven architecture patterns. This skill helps you implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to create testable, scalable applications with proper separation of concerns.
Download the skill ZIP
Upload in Claude
Go to Settings → Capabilities → Skills → Upload skill
Toggle on and start using
Test it
Using "architecture-patterns". Create a Clean Architecture structure for a user management system
Expected outcome:
The skill generates a complete directory structure with domain/entities containing User entity, domain/interfaces with IUserRepository port, use_cases containing CreateUserUseCase and UpdateUserUseCase, adapters/repositories with PostgresUserRepository implementation, and adapters/controllers with UserController for HTTP handling. Each component demonstrates proper dependency flow and separation of concerns.
Using "architecture-patterns". Implement a payment gateway adapter using hexagonal architecture
Expected outcome:
The skill creates a PaymentGatewayPort interface defining the charge method contract, then implements both StripePaymentAdapter for production and MockPaymentAdapter for testing. Both adapters implement the same port interface, allowing easy swapping without changing business logic. The example includes error handling and proper async/await patterns.
Using "architecture-patterns". Design an Order aggregate with DDD patterns
Expected outcome:
The skill designs an Order entity as aggregate root with add_item, calculate_total, and submit methods encapsulating business rules. It includes OrderItem entity, Money value object for currency handling, OrderStatus enum for state management, and domain events like OrderSubmittedEvent. The aggregate enforces invariants and maintains consistency boundaries.
Security Audit
SafeAll 43 static analysis findings are false positives from educational code examples in documentation. The skill teaches software architecture patterns through Python examples showing Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. No executable code, network access, or security vulnerabilities present.
Quality Score
What You Can Build
Design New Backend Service Architecture
Plan and implement a new microservice using Clean Architecture principles with proper layer separation, dependency injection, and testable business logic.
Refactor Monolithic Application
Transform a tightly coupled monolithic application into a well-structured hexagonal architecture with ports and adapters for easier testing and maintenance.
Implement Domain-Driven Design Patterns
Model complex business domains using DDD tactical patterns including aggregates, entities, value objects, and domain events for better domain alignment.
Try These Prompts
Create a Clean Architecture folder structure for an e-commerce order management system with domain entities, use cases, and adapters.
Implement a user repository port interface and PostgreSQL adapter following hexagonal architecture principles with async database access.
Design an Order aggregate with domain entities, value objects, and business rules for adding items, calculating totals, and state transitions.
Refactor this FastAPI endpoint that has business logic in the controller into a proper use case with dependency injection and separation of concerns.
Best Practices
- Always point dependencies inward from outer layers to inner layers, never let domain layer depend on infrastructure
- Use interfaces and ports to define contracts in the domain layer, implement adapters in outer layers for testability
- Keep business logic in domain entities and use cases, controllers should only handle HTTP concerns and delegate to use cases
Avoid
- Placing business logic in controllers or API handlers instead of use cases and domain entities
- Creating anemic domain models with only data properties and no behavior, putting all logic in services
- Tightly coupling domain layer to specific frameworks, databases, or external APIs without abstraction interfaces