home / skills / athola / claude-night-market / architecture-paradigms

architecture-paradigms skill

safe

/plugins/archetypes/skills/architecture-paradigms

This skill helps you select architecture paradigms and route to dedicated paradigm skills to accelerate architecture decisions.

npx playbooks add skill athola/claude-night-market --skill architecture-paradigms

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

7.6 KB

---
name: architecture-paradigms
description: Interactive selector and router for architecture paradigms. Use when
  selecting architecture patterns for new systems, comparing paradigm trade-offs,
  creating architecture decision records, evaluating architecture fit for team size
  and domain complexity, planning implementation roadmaps. Do not use when implementing
  a specific known paradigm - use the specific architecture-paradigm-* skill (hexagonal,
  layered, microservices, etc.) instead. reviewing existing architecture - use architecture-review
  instead. Use this skill BEFORE making architecture decisions. Check even if unsure
  about needs.
category: architecture-decision
tags:
- architecture
- patterns
- selection
- implementation
- adr
dependencies:
- architecture-paradigm-functional-core
- architecture-paradigm-hexagonal
- architecture-paradigm-cqrs-es
- architecture-paradigm-event-driven
- architecture-paradigm-layered
- architecture-paradigm-modular-monolith
- architecture-paradigm-microkernel
- architecture-paradigm-microservices
- architecture-paradigm-service-based
- architecture-paradigm-space-based
- architecture-paradigm-pipeline
- architecture-paradigm-serverless
- architecture-paradigm-client-server
tools:
- paradigm-selector
- implementation-planner
- compatibility-checker
usage_patterns:
- paradigm-selection
- architecture-review
- implementation-planning
- adr-creation
complexity: intermediate
estimated_tokens: 280
---
## Table of Contents

- [Quick Scenario Router](#quick-scenario-router)
- [3-Step Selection Workflow](#3-step-selection-workflow)
- [Available Paradigm Skills](#available-paradigm-skills)
- [Integration with Other Skills](#integration-with-other-skills)
- [Exit Criteria](#exit-criteria)

# Architecture Paradigm Router

This skill helps you **select** the right architecture paradigm(s) for your system, then **routes** you to the specific paradigm skill for implementation details.

## Quick Scenario Router

Match your needs to the recommended paradigm:

| Your Scenario | Primary Paradigm | Load Skill |
|---------------|------------------|------------|
| **Enterprise app with multiple teams** | Microservices or Modular Monolith | `architecture-paradigm-microservices` or `architecture-paradigm-modular-monolith` |
| **Complex business rules & testing** | Functional Core, Imperative Shell | `architecture-paradigm-functional-core` |
| **Real-time/event processing** | Event-Driven Architecture | `architecture-paradigm-event-driven` |
| **Legacy system modernization** | Hexagonal (Ports & Adapters) | `architecture-paradigm-hexagonal` |
| **Cloud-native/bursty workloads** | Serverless | `architecture-paradigm-serverless` |
| **ETL/data processing pipeline** | Pipeline Architecture | `architecture-paradigm-pipeline` |
| **Simple CRUD app** | Layered Architecture | `architecture-paradigm-layered` |
| **Command/query separation** | CQRS + Event Sourcing | `architecture-paradigm-cqrs-es` |

## 3-Step Selection Workflow

### Step 1: Define Your Needs

**Primary Concerns** (select all that apply):
- **Testability**: Isolate business logic → `functional-core` or `hexagonal`
- **Team Autonomy**: Independent deployment → `microservices` or `modular-monolith`
- **Infrastructure Flexibility**: Swap databases/frameworks → `hexagonal`
- **Real-time Scaling**: Variable loads with events → `event-driven` or `space-based`
- **Simplicity**: Maintainable without complexity → `layered` or `modular-monolith`
- **Legacy Integration**: Work with existing systems → `hexagonal` or `microkernel`

**System Context**:
- **Team Size**: `< 5` → Layered/Functional Core | `5-15` → Modular Monolith | `15-50` → Microservices | `50+` → Microservices/Space-Based
- **Domain Complexity**: `Simple` → Layered | `Moderate` → Hexagonal/Modular Monolith | `Complex` → Functional Core/CQRS | `Highly Complex` → Microservices/Event-Driven

### Step 2: Evaluate Paradigms

Based on your needs from Step 1, review these options:

**For Testability & Business Logic**
- Load `architecture-paradigm-functional-core` - Isolates business logic from infrastructure
- Load `architecture-paradigm-hexagonal` - Clear domain/infrastructure boundaries

**For Team Autonomy**
- Load `architecture-paradigm-microservices` - Independent deployment and scaling
- Load `architecture-paradigm-modular-monolith` - Team autonomy without distributed complexity

**For Infrastructure Flexibility**
- Load `architecture-paradigm-hexagonal` - Swap infrastructure without domain changes

**For Simplicity & Maintainability**
- Load `architecture-paradigm-layered` - Simple, well-understood separation

**For Real-time Event Processing**
- Load `architecture-paradigm-event-driven` - Scalable, decoupled processing
- Load `architecture-paradigm-space-based` - In-memory data grids for linear scalability

**For Legacy Integration**
- Load `architecture-paradigm-microkernel` - Plugin architecture for extensible platforms
- Load `architecture-paradigm-hexagonal` - Adapters for external systems

### Step 3: Load Paradigm Skill for Implementation

Once you've selected your paradigm(s), load the specific skill for detailed guidance:

```bash
# Example: You selected Hexagonal Architecture
Skill(archetypes:architecture-paradigm-hexagonal)
```

The individual paradigm skill provides:
- ✅ Complete implementation guide
- ✅ ADR templates
- ✅ Migration checklist
- ✅ Code examples
- ✅ Testing strategies
- ✅ Risk assessments

## Available Paradigm Skills

| Paradigm | Complexity | Team Size | Best For | Skill Name |
|----------|------------|-----------|----------|------------|
| **Functional Core** | Medium | Small-Large | Complex business logic | `architecture-paradigm-functional-core` |
| **Hexagonal** | Medium | Small-Large | Infrastructure changes | `architecture-paradigm-hexagonal` |
| **Layered** | Low | Small-Medium | Simple domains | `architecture-paradigm-layered` |
| **Modular Monolith** | Medium | Medium-Large | Evolving systems | `architecture-paradigm-modular-monolith` |
| **Microservices** | High | Large | Complex domains | `architecture-paradigm-microservices` |
| **Event-Driven** | High | Medium-Large | Real-time processing | `architecture-paradigm-event-driven` |
| **CQRS + ES** | High | Medium-Large | Audit trails | `architecture-paradigm-cqrs-es` |
| **Service-Based** | Medium | Medium | Coarse-grained services | `architecture-paradigm-service-based` |
| **Serverless** | Medium | Small-Medium | Cloud-native/bursty | `architecture-paradigm-serverless` |
| **Microkernel** | Medium | Small-Medium | Plugin systems | `architecture-paradigm-microkernel` |
| **Space-Based** | High | Large | Linear scalability | `architecture-paradigm-space-based` |
| **Pipeline** | Low | Small-Medium | ETL workflows | `architecture-paradigm-pipeline` |
| **Client-Server** | Low | Small | Traditional apps | `architecture-paradigm-client-server` |

## Integration with Other Skills

- **Architecture Review**: Use this skill first to select paradigms, then `/architecture-review` for evaluation
- **Implementation Planning**: Select paradigms here, then `/writing-plans` for detailed task breakdown
- **Refactoring**: Identify target paradigms here, then use paradigm-specific skills for migration strategies

## Exit Criteria

- [ ] At least one paradigm is selected with clear rationale
- [ ] Specific paradigm skill has been loaded for detailed guidance
- [ ] Ready to create ADR or implementation plan

## Next Steps

1. **Load the specific paradigm skill** - Use `Skill(archetypes:architecture-paradigm-NAME)`
2. **Generate an ADR** - Use the paradigm's ADR templates
3. **Create implementation plan** - Use paradigm's migration checklist
4. **Set up monitoring** - Track success metrics from paradigm guidance

Overview

This skill is an interactive selector and router that helps you choose the right software architecture paradigm before you make design decisions. It maps your system context, team size, and primary concerns to recommended paradigms and then routes you to the specific paradigm skill for implementation guidance. Use it to compare trade-offs, create ADRs, and plan implementation roadmaps.

How this skill works

Answer a short set of questions about team size, domain complexity, and primary concerns (testability, autonomy, real-time needs, legacy integration, simplicity). The router matches your inputs to one or more paradigms and recommends the best-fit skill(s). Once a paradigm is selected, it provides links or commands to load the detailed paradigm skill that contains ADR templates, migration checklists, tests, and code examples.

When to use it

When starting a new system and you need to pick an architecture before detailed design
When comparing trade-offs across multiple paradigms for the same problem
When drafting an architecture decision record (ADR) to justify choices
When evaluating fit by team size, domain complexity, or operational constraints
When planning an implementation or migration roadmap and needing a targeted skill

Best practices

Start here even if you’re unsure — it narrows options and prevents premature decisions
State primary concerns (testability, team autonomy, legacy integration) before choosing
Combine paradigms when appropriate (e.g., modular monolith now, microservices later)
Select at least one paradigm with a clear rationale and load the corresponding skill
Use the recommended paradigm skill for implementation details, ADRs, and checklists

Example use cases

A small team choosing between layered and functional-core for a business rules-heavy app
A growing organization deciding whether to adopt microservices or a modular monolith
Modernizing a legacy system and routing to hexagonal or microkernel migration guidance
Designing a real-time event processing system and routing to event-driven or space-based paradigms
Evaluating serverless vs. pipeline design for cloud-native, bursty workloads

FAQ

Can I pick more than one paradigm?

Yes. The router supports hybrid approaches and recommends combined strategies when they fit the use case.

Should I use this skill when implementing the chosen paradigm?

No. Use this skill to choose the paradigm, then load the specific paradigm skill for implementation details and code.