designing-architecture

Map requirements to architectural patterns and document decisions with ADRs.

Updated May 18, 2026
One-click install
npx skills add https://github.com/bbara04/openchamber-complete --skill designing-architecture-bbara04
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: designing-architecture
Source: https://github.com/bbara04/openchamber-complete/tree/main/opencode-config/skill/designing-architecture
Command: npx skills add https://github.com/bbara04/openchamber-complete --skill designing-architecture-bbara04

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designing software architecture is hard to get right up front, and teams often end up with fragile systems, unclear boundaries, and costly refactors.

Core Features & Use Cases

  • Clarifies decision-making principles: SOLID, dependency direction, and layering rules to reduce coupling and improve maintainability.
  • Recommends proven architectural patterns: layered architecture, hexagonal (ports & adapters), microservices, and event-driven approaches—plus when to use or avoid each.
  • Applies design methodologies to real systems: DDD concepts (bounded contexts, ubiquitous language, context maps) and tactical building blocks (entities, aggregates, domain events).
  • Helps validate system trade-offs: scalability, resilience, data consistency patterns, and an ADR template to document decisions.

Quick Start

Use the designing-architecture skill to review an existing design and propose a refactoring plan with a recommended pattern, DDD boundaries, and the key trade-offs.

Frequently Asked Questions about designing-architecture

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

FAQPage Schema
How do I choose between layered, hexagonal, and microservices architecture for my system?

System design pattern selection depends on your scalability needs and coupling tolerance. The skill maps requirements to layered, hexagonal, microservices, or event-driven approaches, providing decision checklists and trade-off analysis for when to use or avoid each pattern to ensure maintainability.

When do I need DDD building blocks like bounded contexts and aggregates in software architecture?

DDD building blocks are needed when clarifying complex domain boundaries and ubiquitous language. The skill applies tactical DDD concepts such as entities, aggregates, domain events, and context maps to real systems, helping establish clear boundaries and reduce coupling in your architecture.

What's the best way to document architecture decisions and trade-offs for scalability planning?

Documenting architecture decisions is best done using an ADR template. The skill helps validate system trade-offs in scalability, resilience, and data consistency patterns, providing an ADR format to record decisions and the reasoning behind refactoring choices.

Can I apply SOLID principles and dependency direction rules to an existing monolith for refactoring?

Yes, SOLID principles and dependency direction rules can be applied to monolith refactoring. The skill clarifies decision-making principles and layering rules to reduce coupling, reviewing existing designs and proposing a refactoring plan with recommended patterns and key trade-offs.

Why does event-driven architecture improve resilience compared to a modular monolith?

Event-driven architecture improves resilience by enabling asynchronous processing and loose coupling between services. The skill covers event-driven approaches alongside modular monolith patterns, mapping requirements to proven architectural patterns and evaluating trade-offs for data consistency and system resilience.