
Architecture Patterns
FreeMaster backend architecture for scalable systems.
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 source1. Install with the skills CLI
npx skills add davila7/claude-code-templates/architecture-patterns --agent claude-code2. 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 davila7Architecture 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
- Clarify domain boundaries, constraints, and scalability targets.
- Select an architecture pattern that fits the domain complexity.
- Define module boundaries, interfaces, and dependency rules.
- Provide migration steps and validation checks.
- 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.mdfor detailed patterns, checklists, and templates.
Frequently asked questions about Architecture Patterns
Similar skills
Python PyPI Package Builder
Streamline the process of creating and publishing Python packages.
Minecraft Plugin Development
Streamline your Minecraft server plugin creation.
MCP Server Builder
Easily build .NET MCP servers with the latest standards.
CommunityToolkit.Mvvm Messenger
Decoupled communication for ViewModels in .NET applications.
MVVM Toolkit DI
Streamline ViewModel integration with Dependency Injection in .NET.
MCP Apps Builder
Essential guidelines for MCP server development.
