architect

Analyze architectural decisions and generate ADR-style guidance with design options.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/curphey/bosun --skill architect-curphey
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architect
Source: https://github.com/curphey/bosun/tree/main/skills/architect
Command: npx skills add https://github.com/curphey/bosun --skill architect-curphey

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Architecture decisions are expensive to change later. This skill guides systematic architectural review and design before committing to implementation.

Core Features & Use Cases

  • Phase-based evaluation: requirements understanding, design exploration with options, validation, SOLID checks, boundary checks, ADR templates, and best practices.
  • Encourages documenting architectural decisions with Architecture Decision Records (ADRs) and establishing clear boundaries between modules.
  • Use cases across monoliths, microservices, APIs, and infrastructure patterns to guide design and evolution.

Quick Start

Analyze an architecture proposal and generate ADR-style guidance with multiple design options.

Frequently Asked Questions about architect

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

FAQPage Schema
How do I prevent costly rework when making architecture decisions?

To prevent costly rework, an architecture review surfaces design trade-offs and constraints before implementation. This systematic evaluation validates requirements, explores multiple design options, and enforces SOLID principles to guide system evolution safely.

What is the best way to write an Architecture Decision Record for a microservices system?

Writing an Architecture Decision Record (ADR) for microservices requires documenting specific design options, boundary definitions, and validation checks. This process captures architectural decisions and trade-offs systematically to guide future development and evolution.

How do I validate architecture patterns against SOLID principles and module boundaries?

Validating architecture patterns against SOLID principles requires a phase-based evaluation that checks boundary definitions between modules. This review process ensures component constraints are respected and surfaces structural trade-offs before implementation.

Does this architecture review approach work for both monoliths and microservices?

This architecture review approach works for both monoliths and microservices. It systematically evaluates multi-component systems, API designs, and infrastructure patterns to guide design and enforce documentation requirements across various architectural scales.

When do I need to document architectural decisions with ADR templates?

You need to document architectural decisions with ADR templates when evaluating multi-component systems or API designs. Establishing clear boundaries and recording trade-offs early prevents costly future rework and guides long-term system evolution.

What are the limitations of relying on architecture patterns without formal validation?

Relying on architecture patterns without formal validation risks costly future rework due to undocumented trade-offs and unclear module boundaries. A systematic review is required to surface hidden constraints and enforce SOLID principles before committing to implementation.