skills.rest
sandeshbagmare
sandeshbagmareCOMMUNITY
Explore all skills by this author →
GitHub

architecture-patterns

Provide architectural guidance for backend systems using Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.

Updated May 30, 2026
Search Tags:#domain-driven design#hexagonal architecture#clean architecture#backend architecture#code structure
One-click install
npx skills add https://github.com/sandeshbagmare/AgenticQ --skill architecture-patterns-sandeshbagmare
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/sandeshbagmare/AgenticQ/tree/main/examples/python_agenticq_demo/.claude/plugins/backend-development/skills/architecture-patterns
Command: npx skills add https://github.com/sandeshbagmare/AgenticQ --skill architecture-patterns-sandeshbagmare

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides solutions to complex backend architecture challenges, helping developers create systems that are easier to maintain, test, and scale.

Core Features & Use Cases

  • Clean Architecture: Offers a structured approach to organizing code, separating concerns, and making dependencies clear.
  • Hexagonal Architecture: Provides flexibility in technology choices, allowing easy swapping of implementations without affecting core logic.
  • Domain-Driven Design: Focuses on understanding and implementing the business domain through models, value objects, and aggregates.
  • Use Case: When building a new microservice or refactoring an existing system, use this Skill to define clear boundaries and design patterns that will simplify maintenance and scaling.

Quick Start

Use the 'architecture-patterns' skill to generate a layered structure for a new service based on Clean Architecture principles.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
What is the best way to structure a backend microservice for maintainability?▼

Clean Architecture provides a structured approach to organizing backend code, separating concerns, and making dependencies clear to simplify maintenance. It defines layered structures and clear test boundaries for new microservices.

How do I separate business logic from technology choices in backend architecture?▼

Hexagonal Architecture isolates core logic from external interfaces, allowing easy swapping of technology implementations without affecting the domain. This pattern provides flexibility and improves the testability of your codebase.

When do I need Domain-Driven Design for my backend system?▼

Domain-Driven Design is needed when you must model complex business domains using aggregates, value objects, and clear boundaries. It focuses on understanding and implementing the business domain to improve system maintainability.

How do I refactor an existing codebase to improve testability and code structure?▼

Refactoring an existing system requires applying architectural patterns like Clean or Hexagonal Architecture to define clear boundaries and interfaces. This process separates concerns and establishes test boundaries to improve code structure.

Can I use these backend architecture patterns for both new development and refactoring?▼

Yes, architectural guidance for Clean Architecture, Hexagonal Architecture, and Domain-Driven Design applies to both building new microservices and refactoring existing systems. It helps define clear boundaries and design patterns for scaling.

Why does my backend architecture make swapping implementations difficult?▼

Your backend architecture likely lacks Hexagonal Architecture principles, which separate core logic from external interfaces. Implementing this pattern allows easy swapping of implementations without affecting core domain logic.

Related Skills

Explore More Software Engineering Skills→
dandudzidandudzi
2

ddd-strategic-design

Map business domains and define bounded contexts with DDD strategic patterns.

Community
Advanced
jonparkdevjonparkdev

plan-clean-architecture

Generate phased Clean Architecture specifications with interfaces and gate checks.

Community
Advanced
Marwan78888Marwan78888
16

microservices-architect

Map microservice boundaries and apply Saga or CQRS patterns for domain-driven decomposition.

Community
Advanced
ricablericable
1

V3 DDD Architecture

Decompose monolithic structures into modular bounded contexts with a microkernel pattern.

Community
Advanced