architecture-patterns

Implements Clean Architecture, Hexagonal Architecture, and Domain-Driven Design with directory structures and code examples.

1|Updated Feb 19, 2026
One-click install
npx skills add https://github.com/yusufcmg/Antigravity-Agents-Workflows --skill architecture-patterns-yusufcmg
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/yusufcmg/Antigravity-Agents-Workflows/tree/main/.agent/skills/backend/architecture-patterns
Command: npx skills add https://github.com/yusufcmg/Antigravity-Agents-Workflows --skill architecture-patterns-yusufcmg

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides guidance and examples for implementing advanced backend architectural patterns, helping developers build more maintainable, testable, and scalable applications.

Core Features & Use Cases

  • Implement Clean Architecture: Structure code with clear layers (Entities, Use Cases, Adapters, Infrastructure).
  • Apply Hexagonal Architecture: Decouple the core domain from external concerns using Ports and Adapters.
  • Utilize Domain-Driven Design (DDD): Model complex business domains with Value Objects, Entities, Aggregates, and Domain Events.
  • Use Case: When architecting a new microservice, use this Skill to choose and implement the most suitable pattern (e.g., Clean Architecture for a new feature, DDD for a complex business domain).

Quick Start

Use the architecture-patterns skill to generate a basic project structure for Clean Architecture in Python.

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 backend project using Clean Architecture or Hexagonal Architecture?

To structure a backend project using Clean Architecture, you organize code into clear layers: Entities, Use Cases, Adapters, and Infrastructure. Hexagonal Architecture decouples the core domain from external concerns using Ports and Adapters, providing detailed directory structures and code examples for maintainability.

When should I use Domain-Driven Design for a complex backend system?

Use Domain-Driven Design (DDD) when modeling complex business domains. DDD helps manage complexity by utilizing Value Objects, Entities, Aggregates, and Domain Events, ensuring your software accurately reflects core business logic and improves testability.

What is the best way to decouple business logic from external infrastructure?

The best way to decouple business logic from external infrastructure is by applying Hexagonal Architecture. It isolates the core domain using Ports and Adapters, allowing external concerns like databases to be swapped without modifying core business rules.

Can I generate a project directory structure for a specific architecture pattern?

Yes, you can generate a basic project directory structure for specific patterns. The skill provides detailed directory structures and code examples, allowing you to quickly scaffold implementations like Clean Architecture in Python.

How do Clean Architecture and Hexagonal Architecture differ for microservices?

Clean Architecture structures code into concentric layers like Entities and Use Cases for clear dependency inversion. Hexagonal Architecture focuses on isolating the domain entirely through Ports and Adapters, which is highly effective for decoupling microservices from external systems.