architect-advisor

Review software designs using hexagonal architecture, DDD, and Beck's rules.

1|Updated Mar 25, 2026
One-click install
npx skills add https://github.com/davidarce/devrune-starter-catalog --skill architect-advisor
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architect-advisor
Source: https://github.com/davidarce/devrune-starter-catalog/tree/main/skills/architect-advisor
Command: npx skills add https://github.com/davidarce/devrune-starter-catalog --skill architect-advisor

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Provide expert guidance on clean architecture patterns, hexagonal architecture, and Domain-Driven Design.

Core Features & Use Cases

  • Hexagonal Architecture diagrams and dependency rules
  • Review methodology based on Beck's 4 rules
  • Quality checklist and anti-patterns to flag
  • Advisor mode for SDD orchestrator integration

Quick Start

Provide an architecture review for a given design, applying hexagonal architecture, DDD, and Beck's rules.

Frequently Asked Questions about architect-advisor

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

FAQPage Schema
How do I perform a clean architecture design review for my software project?

A clean architecture design review evaluates your software project against hexagonal architecture, Domain-Driven Design, and Beck's rules to ensure robust modularity and clear dependency boundaries. It applies a structured workflow with a quality checklist to flag anti-patterns.

What is hexagonal architecture and how does it enforce dependency boundaries?

Hexagonal architecture is a structural pattern that isolates core domain logic from external frameworks by defining explicit dependency rules and ports. It ensures zero-framework domain independence, keeping your business logic completely decoupled from infrastructure.

How do I apply Beck's rules to evaluate software architecture modularity?

Applying Beck's rules to architecture involves checking if the code dependencies point toward abstractions, ensuring zero-framework domain independence and explicit dependency boundaries. This structured review workflow identifies anti-patterns that threaten scalable systems.

When do I need Domain-Driven Design for building scalable systems?

You need Domain-Driven Design when building scalable systems that require strict modularity and zero-framework domain independence. It provides expert guidance for robust software projects by isolating business logic and establishing clear dependency boundaries.

Does this architecture advisor support dependency inversion for zero-framework domain independence?

Yes, the architecture advisor supports dependency inversion by enforcing explicit dependency rules and hexagonal architecture patterns. It ensures zero-framework domain independence through a structured review workflow and a quality checklist that flags anti-patterns.

What are common clean architecture anti-patterns to flag during a design review?

Common anti-patterns to flag during a design review include framework dependencies leaking into the domain and reversed dependency boundaries. The review uses a quality checklist and Beck's rules to identify these violations against hexagonal architecture and DDD principles.