rai-architecture-review

Audit changed files against design documents using Beck's four rules to produce heuristic-tagged findings and a PASS/SIMPLIFY verdict.

71|8|Updated Feb 13, 2026
One-click install
npx skills add https://github.com/humansys/raise --skill rai-architecture-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rai-architecture-review
Source: https://github.com/humansys/raise/tree/main/packages/raise-cli/src/raise_cli/skills_base/rai-architecture-review
Command: npx skills add https://github.com/humansys/raise --skill rai-architecture-review

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Prevents over-engineering and unnecessary complexity by judging whether implemented code is necessary and proportional to the design intent, helping teams avoid gold-plating and speculative work.

Core Features & Use Cases

  • Necessity Audit (YAGNI): Detect single implementations, wrappers without logic, unused parameters, test-only consumers, and dead exports.
  • Proportionality & Duplication Checks: Measure indirection depth, abstraction-to-LOC ratio, configuration misuse, semantic duplication, pattern drift, and import fan-in.
  • Systemic & Lean Compliance (epic scope): Identify orphaned abstractions, coupling direction issues, cyclic dependencies, shotgun surgery, and violations of MVP/design/patterns.
  • Use Cases: Run after a story implementation to verify minimal, correct design; run at epic close for cross-module systemic issues; run on-demand when complexity feels disproportionate.

Quick Start

Run an architecture review on the current story by loading the design document, changed files, and relevant patterns, then produce heuristic-tagged findings and a verdict.

Frequently Asked Questions about rai-architecture-review

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

FAQPage Schema
How do I detect over-engineering and unnecessary abstractions in implemented code?

Detect over-engineering by auditing implemented code for necessity and proportionality using Beck's four rules, checking for unused parameters, dead exports, and wrapper layers without logic against the original design intent.

What is a YAGNI necessity audit for software architecture?

A YAGNI necessity audit identifies speculative work by finding single implementations, wrappers without logic, unused parameters, test-only consumers, and dead exports to prevent gold-plating in the codebase.

How do I perform a post-implementation architecture review for a user story?

Perform a post-implementation architecture review by loading the design document, analyzing git diffs of changed files, and evaluating established patterns across project modules to produce heuristic-tagged findings and a PASS or SIMPLIFY verdict.

Do I need design documents and git diffs to run a code proportionality check?

Yes, you need design documents, git diffs, project language detection, and access to the knowledge graph to evaluate design proportionality and measure the abstraction-to-LOC ratio accurately.

How do I identify systemic pattern drift and cyclic dependencies at epic close?

Identify systemic issues by running an epic-scope architecture review to detect orphaned abstractions, coupling direction issues, cyclic dependencies, and shotgun surgery across project modules to ensure lean compliance.

When should I run a design proportionality audit on my codebase?

Run a design proportionality audit after a story implementation to verify minimal correct design, at epic close for cross-module systemic issues, or on-demand when complexity feels disproportionate to the design intent.