architecture-audit
Systematically explores your codebase to identify shallow modules and coupling friction, then frames the problem space and generates multiple interface design proposals via parallel sub-agents. Compares alternatives and files the recommended refactor as a GitHub issue RFC, grounding each suggestion in actual call patterns and dependency boundaries.
Architecture Audit surfaces shallow modules and coupling friction in your codebase, then proposes deepening refactors as GitHub issue RFCs.
AI-generated summary based on this skill's SKILL.md
Install
softspark/ai-toolkit/architecture-audit · repository language: Python
git clone https://github.com/softspark/ai-toolkit
cp -r ai-toolkit/app/skills/architecture-audit ~/.claude/skills/architecture-auditnpx skillfed install softspark/ai-toolkit/architecture-auditFrequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
What does architecture-audit do with my codebase?
architecture-audit systematically explores your codebase to identify shallow modules and coupling friction, then frames the problem space and generates multiple interface design proposals via parallel sub-agents. It compares alternatives and files the recommended refactor as a GitHub issue RFC, grounding each suggestion in actual call patterns and dependency boundaries.
How does architecture-audit find shallow modules in my code?
architecture-audit audits your codebase for shallow modules and architectural friction by analyzing module depth, interface boundaries, and dependency patterns. It surfaces modules that lack sufficient abstraction or responsibility separation, then proposes deepening refactors backed by concrete call-pattern evidence.
Can architecture-audit detect tightly coupled modules?
Yes. architecture-audit identifies tightly coupled modules and integration risks in code seams by examining cross-module dependencies and call chains. It flags coupling friction points and recommends boundary improvements to reduce architectural debt and improve testability.
Does architecture-audit generate GitHub RFCs?
architecture-audit generates GitHub RFC issues for module interface redesign with multiple design options. It compares alternatives, frames the problem space, and files the recommended refactor backed by actual dependency analysis and call-pattern evidence.
How can architecture-audit improve my code's testability?
architecture-audit improves testability by deepening modules and replacing shallow unit tests with boundary tests. By surfacing architectural problems and proposing interface redesigns, it helps you establish clearer module contracts and stronger integration points.
What architectural problems does architecture-audit identify?
architecture-audit explores your codebase organically to surface architectural problems before proposing solutions. It detects shallow modules, coupling friction, integration risks, and testability gaps—then recommends module deepening opportunities and interface optimizations grounded in real code patterns.
SKILL.md
rendered from the published skill — quoted content, verbatim
Architecture Audit
$ARGUMENTS
Explore a codebase organically, surface architectural friction, and propose module-deepening refactors as GitHub issue RFCs.
Usage
/architecture-audit [area to audit or 'full codebase']
What This Command Does
- Explores codebase organically — friction IS the signal
- Presents deepening candidates to user
- Frames problem space for chosen candidate
- Spawns 3+ parallel sub-agents for radically different interface designs
- Compares and recommends
- Files RFC as GitHub issue
Key Concept
A deep module (Ousterhout) has a small interface hiding a large implementation. Deep modules enhance testability, AI navigation, and enable boundary testing.
A shallow module has a large interface with thin implementation — avoid.
Process
1. Organic Exploration
Use
(truncated - see the full file via the links below)
Read as markdown · JSON record · Browse the source repository
File tree — 1 file
app/skills/architecture-audit/SKILL.md