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
Decision gist · record as of 2026-07-27
Architecture Audit surfaces shallow modules and coupling friction in your codebase, then proposes deepening refactors as GitHub issue RFCs. 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.
Use it when
- architecture-audit audits your codebase for shallow modules and architectural friction by analyzing module depth, interface boundaries.
- Yes.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Install
softspark/ai-toolkit/architecture-audit · repository language: Python
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently 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)
File tree — 1 file
app/skills/architecture-audit/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Audit codebase for shallow modules and architectural friction to propose deepening refactors”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master three foundational backend architecture approaches: Clean Architecture's layered dependency flow, Hexagonal Architecture's port-and-adapter model for technology independence, and Domain-Driven Design's strategic and tactical patterns for complex domains. Use this skill when designing new systems, refactoring monoliths, or establishing architecture standards for your team.
This skill guides you through building Spring Boot applications with clean architecture principles, ensuring domain logic stays independent of frameworks and infrastructure. Learn to structure layered packages, implement ports and adapters, apply domain-driven design tactical patterns, and maintain strict dependency rules that keep your codebase testable and maintainable.
This skill structures architecture decisions by enforcing a rigorous trade-off analysis: context, constraints, at least three viable options, and explicit consequences. It produces formal decision records (ADR/RFC/RFD) that capture both positive and negative outcomes, ensuring decisions remain auditable and reversible.
Debug helps you trace application issues methodically from symptom to root cause using structured log analysis, error parsing, and hypothesis testing. It enforces a disciplined four-phase workflow: investigate the error completely, analyze patterns in working code, form and test a single hypothesis, then implement the fix—preventing the common trap of patching symptoms instead of solving underlying problems.
cpp-rules provides comprehensive C++ development standards drawn from ai-toolkit's rule library. It covers naming conventions, modern language features, memory management with smart pointers, and framework guidance for CMake, Boost, Qt, and gRPC. The rules emphasize RAII patterns, error handling strategies, concurrency practices, and design patterns to maintain code quality and security across C++ projects.
Architecting Security guides strategic security design through defense-in-depth layering, zero trust implementation, and structured threat modeling. Map controls to NIST CSF, CIS Controls, and ISO 27001 for governance and compliance across greenfield systems, cloud migrations, and enterprise audits.