architecture-patterns

Implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design patterns.

2|Updated Feb 5, 2026
One-click install
npx skills add https://github.com/yashvinthan/DuskSpendr --skill architecture-patterns-yashvinthan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/yashvinthan/DuskSpendr/tree/main/.agents/skills/architecture-patterns
Command: npx skills add https://github.com/yashvinthan/DuskSpendr --skill architecture-patterns-yashvinthan

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides guidance and implementation examples for structuring complex backend systems using established architectural patterns, leading to more maintainable, testable, and scalable applications.

Core Features & Use Cases

  • Pattern Implementation: Demonstrates Clean Architecture, Hexagonal Architecture, and Domain-Driven Design (DDD).
  • Guidance: Offers best practices and common pitfalls for each pattern.
  • Use Case: When starting a new backend project or refactoring a monolith, use this Skill to understand and apply a suitable architectural pattern like Clean Architecture to ensure a well-organized and maintainable codebase.

Quick Start

Use the architecture-patterns skill to generate a directory structure for a new Clean Architecture project.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I structure a new backend project using clean architecture?

Clean architecture structures a backend by separating code into entities, use cases, repositories, and adapters. This Skill generates detailed directory structures and code examples to help you organize new projects or refactor monoliths for better maintainability.

What is the difference between hexagonal architecture and domain-driven design?

Hexagonal architecture isolates business logic through ports and adapters, whereas domain-driven design models software around the business domain. This Skill provides detailed explanations and implementation guidance for applying both patterns in complex backend systems.

When should I refactor a monolith with domain-driven design?

Refactor a monolith with domain-driven design when business logic becomes too complex to maintain. This Skill provides best practices and highlights common pitfalls to guide your DDD implementation, ensuring a well-organized and scalable codebase.

Can I use hexagonal architecture for an existing backend application?

Yes, you can apply hexagonal architecture to existing backend applications by isolating core logic via ports and adapters. This Skill provides detailed explanations and code examples to help you structure repositories and adapters for better testability.

What are common pitfalls when implementing clean architecture?

Common clean architecture pitfalls include improper dependency inversion and mixing concerns across architectural layers. This Skill identifies these issues and provides best practices to ensure your entities, use cases, and repositories remain properly decoupled and maintainable.