hai-architecture

Review software architecture for complexity, weak boundaries, and design risks.

278|15|Updated Mar 25, 2026
One-click install
npx skills add https://github.com/hylarucoder/hai-stack --skill hai-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: hai-architecture
Source: https://github.com/hylarucoder/hai-stack/tree/main/skills/hai-architecture
Command: npx skills add https://github.com/hylarucoder/hai-stack --skill hai-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps teams identify hidden software complexity, weak boundaries, and risky architecture decisions before they become expensive maintenance problems.

Core Features & Use Cases

  • Evidence-Grounded Architecture Reviews: Analyze modules, dependencies, ownership boundaries, and change amplification using John Ousterhout's A Philosophy of Software Design principles.
  • Design Decision Critique: Compare architectural options, explain tradeoffs, and recommend deeper module boundaries with why-not alternatives and adversarial checks.
  • Use Case: Review a growing backend service where feature changes require touching many packages, then produce an architecture map, prioritized findings, and a plan to reduce coupling.

Quick Start

Ask the AI to use the hai-architecture skill to review this system design and identify the highest-impact complexity problems with evidence.

Frequently Asked Questions about hai-architecture

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

FAQPage Schema
How do I identify sources of software complexity in a growing backend service?

To identify software complexity, review your architecture's module boundaries and dependencies to expose hidden coupling and change amplification. This process applies A Philosophy of Software Design principles to produce evidence-grounded findings and an architecture map pinpointing high-impact risks.

What is the best way to perform an evidence-based architecture review?

The best way to perform an architecture review is by analyzing modules, ownership boundaries, and change amplification using A Philosophy of Software Design principles. This yields a prioritized findings report and a targeted plan to reduce system coupling.

How do I evaluate weak module boundaries and risky design decisions?

You evaluate weak module boundaries by comparing architectural options, explaining tradeoffs, and conducting adversarial checks. This critique recommends deeper module boundaries with why-not alternatives to mitigate risky design decisions before they cause maintenance problems.

When do I need a dependency analysis for my software architecture?

You need a dependency analysis when feature changes require touching many packages, indicating high coupling. This analysis maps dependencies to identify weak boundaries and prioritize design decisions that reduce system complexity.

Can I use this approach to review system design decisions for any software project?

Yes, you can review system design decisions for any software project by applying A Philosophy of Software Design principles. It evaluates abstraction quality, module ownership, and dependency structures to produce evidence-based architecture recommendations.

What are the limitations of using A Philosophy of Software Design for complexity analysis?

A limitation of this complexity analysis approach is its reliance on evidence-based findings, meaning it requires sufficient architecture context to map dependencies. It focuses on structural risks and module boundaries rather than runtime performance evaluation.