architecture-audit

Detect architecture drift and structural debt in a TypeScript monorepo.

21|4|Updated Feb 19, 2026
One-click install
npx skills add https://github.com/tylerjrbuell/reactive-agents-ts --skill architecture-audit-tylerjrbuell
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-audit
Source: https://github.com/tylerjrbuell/reactive-agents-ts/tree/main/.agents/skills/architecture-audit
Command: npx skills add https://github.com/tylerjrbuell/reactive-agents-ts --skill architecture-audit-tylerjrbuell

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

System-level detection and triage of architectural drift, dead or disabled systems, over- or under-abstraction, and documentation mismatch across the reactive-agents-ts monorepo to produce a prioritized, actionable baseline before refactor or release work.

Core Features & Use Cases

  • Architecture snapshot: Guides a targeted read order of authoritative docs and high-churn kernel internals to orient the audit.
  • Parallel agent analysis: Runs coordinated inspections for layer violations, documentation accuracy, and simplification opportunities, producing file-level findings with fix direction and risk/effort estimates.
  • Triage and register: Categorizes fixes as immediate, planning, or escalation and appends entries to an Architecture Debt Register for stakeholder planning.
  • Use Cases: Pre-refactor health check, post-feature cleanup to remove scaffolding and flags, and release readiness review to ensure docs match implementation.

Quick Start

Run the architecture-audit skill against the reactive-agents-ts repository to generate a prioritized architecture debt register, file-level findings with fixes and risks, and top simplification opportunities.

Frequently Asked Questions about architecture-audit

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

FAQPage Schema
How do I detect architecture drift and technical debt in a TypeScript monorepo?

Detect architecture drift in a TypeScript monorepo by analyzing package topology and kernel internals to identify layer violations, dead systems, and over-abstraction. This generates file-level findings with fix directions and risk estimates to establish a prioritized baseline before refactoring.

What is the best way to prioritize technical debt before a large monorepo refactor?

Prioritize technical debt before a monorepo refactor by running coordinated parallel inspections to categorize fixes as immediate, planning, or escalation. This triage appends actionable entries to an architecture debt register, identifying top simplification opportunities for stakeholder planning.

How do I check if my documentation has drifted from the codebase implementation?

Check for documentation drift by running parallel agent analysis that inspects documentation accuracy against high-churn kernel internals. This produces file-level findings that expose mismatches between authoritative docs and the actual implementation during release readiness reviews.

Can I audit package topology and provider adapters across a 22-package monorepo?

Yes, you can audit package topology and provider adapters across a 22-package monorepo. The analysis scopes to inspect structural dependencies and layer violations, producing an architecture snapshot that guides targeted fixes and escalations for complex cleanup scenarios.

How do I identify dead or disabled systems during post-feature code cleanup?

Identify dead or disabled systems during post-feature cleanup by analyzing the monorepo for scaffolding, flags, and under-abstraction. The audit produces file-level findings with specific fix directions and effort estimates to safely remove obsolete structural debt.

What are the limitations of running an architecture audit on a TypeScript monorepo?

The primary limitation is that the architecture audit is scoped specifically to the reactive-agents-ts 22-package TypeScript monorepo topology. It targets pre-refactor or cleanup scenarios, meaning its package-level dependency analysis and documentation drift detection are tailored to that specific environment.