New to Claude Skills? Learn how to install them →

Adavila7 on GitHub

Architecture Patterns

Free

Master backend architecture for scalable systems.

Get this skill

Free · Opens the source repo

What Architecture Patterns does

The Architecture Patterns skill provides developers with essential knowledge on proven backend architecture frameworks such as Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. These methodologies are designed to help you create systems that are maintainable, testable, and scalable. By utilizing this skill, you can significantly improve the structure of your applications, making them easier to manage and evolve over time.

This skill is particularly beneficial when designing new backend systems from scratch or refactoring existing monolithic applications. It guides you through establishing architecture standards for your team, ensuring that everyone adheres to best practices. Additionally, it assists in migrating from tightly coupled systems to loosely coupled architectures, which is crucial for enhancing flexibility and reducing dependencies among components.

The skill also emphasizes the importance of creating testable and mockable codebases, which is vital for maintaining high-quality software. It provides a structured approach to planning microservices decomposition, allowing teams to break down complex systems into manageable services that can be developed and deployed independently. The included implementation playbook offers detailed patterns, checklists, and templates to facilitate these processes.

In summary, the Architecture Patterns skill is an invaluable resource for developers looking to enhance their backend system design capabilities. Whether you are starting a new project or improving an existing one, this skill equips you with the knowledge and tools necessary to build robust and scalable systems.

When to use it

Use this skill when designing new backend systems or refactoring existing applications for better structure and performance.

When not to use it

Avoid this skill for small, localized refactors or when primarily dealing with frontend systems without backend changes.

What you can build with it

Designing a New Backend System

Utilize the skill to select an appropriate architecture pattern that aligns with your project's complexity and scalability requirements.

Refactoring a Monolithic Application

Apply the principles from this skill to break down a monolithic application into a more maintainable and loosely coupled architecture.

Establishing Team Architecture Standards

Use the knowledge gained from this skill to create a set of architecture standards that your development team can follow.

How to install Architecture Patterns

View source

1. Install with the skills CLI

npx skills add davila7/claude-code-templates/architecture-patterns --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by davila7

Architecture Patterns

Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems.

Use this skill when

  • Designing new backend systems from scratch
  • Refactoring monolithic applications for better maintainability
  • Establishing architecture standards for your team
  • Migrating from tightly coupled to loosely coupled architectures
  • Implementing domain-driven design principles
  • Creating testable and mockable codebases
  • Planning microservices decomposition

Do not use this skill when

  • You only need small, localized refactors
  • The system is primarily frontend with no backend architecture changes
  • You need implementation details without architectural design

Instructions

  1. Clarify domain boundaries, constraints, and scalability targets.
  2. Select an architecture pattern that fits the domain complexity.
  3. Define module boundaries, interfaces, and dependency rules.
  4. Provide migration steps and validation checks.
  5. For workflows that must survive failures (payments, order fulfillment, multi-step processes), use durable execution at the infrastructure layer — frameworks like DBOS persist workflow state, providing crash recovery without adding architectural complexity.

Refer to resources/implementation-playbook.md for detailed patterns, checklists, and templates.

Related Skills

Works well with: event-sourcing-architect, saga-orchestration, workflow-automation, dbos-*

Resources

  • resources/implementation-playbook.md for detailed patterns, checklists, and templates.

Frequently asked questions about Architecture Patterns

Similar skills