audit-structure

Audit repository topology and dependency design for structural defects.

10|5|Updated Mar 3, 2026
One-click install
npx skills add https://github.com/JHostalek/dotclaude --skill audit-structure
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: audit-structure
Source: https://github.com/JHostalek/dotclaude/tree/main/skills/audit-structure
Command: npx skills add https://github.com/JHostalek/dotclaude --skill audit-structure

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill identifies structural defects that obscure ownership, weaken module boundaries, create forbidden dependencies, and increase the cost and risk of future changes.

Core Features & Use Cases

  • Topology and Ownership Analysis: Reconstruct domains, deployables, runtime units, data ownership, and change boundaries before judging the repository tree.
  • Boundary and Dependency Auditing: Detect misplaced files, god-modules, leaky interfaces, import cycles, layer-direction violations, hidden coupling, and unauthorized data access.
  • Lifecycle and Evolution Review: Inspect composition, initialization, shutdown, deployment, migration, compatibility, and architecture-enforcement paths for structural failures.
  • Evidence-Based Corrections: Classify defects, improvements, intentional constraints, migrations, and unresolved questions while requiring concrete evidence and safe verification.
  • Use Case: Apply this Skill when a repository has unclear ownership, recurring cross-module changes, tangled imports, or a directory structure that no longer reflects its architecture.

Quick Start

Use the audit-structure skill to review the repository topology at the specified path and report confirmed structural defects with evidence, safe corrections, and completion status for every applicable review area.

Frequently Asked Questions about audit-structure

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

FAQPage Schema
How do I find layering violations and import cycles in my repository?

An architecture audit detects layering violations and import cycles by reconstructing module boundaries and dependency topology to expose structural defects with concrete evidence from source, runtime, and build paths. It classifies these violations and provides safe correction guidance.

What is module boundary analysis and when do I need it for my codebase?

Module boundary analysis is the process of reconstructing domains, deployables, and data ownership to evaluate structural integrity. You need it when a repository has unclear ownership, recurring cross-module changes, tangled imports, or a directory structure that no longer reflects its architecture.

How do I audit repository structure for god-modules and misplaced files?

Auditing repository structure for god-modules and misplaced files requires evidence-based analysis across source, runtime, data, and deployment boundaries. The audit inspects topology and ownership to identify defects that weaken boundaries or increase change risk.

Can I analyze hidden runtime coupling and data ownership in a monorepo?

Yes, you can analyze hidden runtime coupling and data ownership by inspecting composition, initialization, shutdown, and migration paths. The audit requires evidence-based analysis across runtime units and data boundaries to confirm structural failures and unauthorized access.

What is the best way to detect evolving deployment boundaries and leaky interfaces?

The best way to detect evolving deployment boundaries and leaky interfaces is a topology audit that inspects lifecycle, tooling, and migration paths. It classifies defects, improvements, and intentional constraints while requiring concrete evidence and safe verification.

When should I not perform a structural refactoring of module boundaries?

You should avoid structural refactoring when the audit identifies intentional constraints or ongoing migrations rather than confirmed defects. The process distinguishes between actual structural failures, intentional architecture decisions, and unresolved questions to ensure safe corrections.