adv-improve-codebase-architecture

Identify shallow modules and generate HTML reports with Mermaid diagrams.

4|Updated Jan 22, 2026
One-click install
npx skills add https://github.com/Sharper-Flow/Advance --skill adv-improve-codebase-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: adv-improve-codebase-architecture
Source: https://github.com/Sharper-Flow/Advance/tree/main/skills/adv-improve-codebase-architecture
Command: npx skills add https://github.com/Sharper-Flow/Advance --skill adv-improve-codebase-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses architectural friction by identifying shallow modules that are difficult to test or navigate, helping you refactor them into deep, maintainable components.

Core Features & Use Cases

  • Architectural Scanning: Automatically analyzes codebase structure to find shallow modules and leakage across seams.
  • Visual Reporting: Generates self-contained HTML reports with Mermaid diagrams and before/after visualizations to communicate refactoring candidates.
  • Refactoring Guidance: Provides a structured grilling loop to refine designs, update domain models, and record architectural decisions.

Quick Start

Run the adv-improve-codebase-architecture skill to scan the current directory for deepening opportunities and generate an HTML report.

Frequently Asked Questions about adv-improve-codebase-architecture

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

FAQPage Schema
How do I identify shallow modules in my codebase for refactoring?

To identify shallow modules for refactoring, scan your codebase structure to detect architectural friction and module leakage. This process highlights components that are difficult to test or navigate, pinpointing exact consolidation candidates requiring interface hardening.

How do I visualize architectural refactoring opportunities in my codebase?

You can visualize architectural refactoring opportunities by generating self-contained HTML reports. These reports feature Mermaid diagrams and before/after visualizations that clearly communicate deepening candidates and structural leakage across your codebase seams.

What is architectural deepening in software engineering?

Architectural deepening is a software engineering refactoring technique that consolidates shallow modules into deep, maintainable components. It improves testability and module locality by hardening interfaces and applying specific domain vocabulary and architectural principles.

How do I refactor code to improve testability and module locality?

To refactor code for improved testability and module locality, apply a structured grilling loop to refine designs, update domain models, and record architectural decisions. This ensures shallow components transform into hardened, maintainable modules.

Do I need specific domain vocabulary to scan my codebase architecture?

Yes, architectural scanning requires adherence to specific domain vocabulary and architectural principles defined within your project context. This ensures the analysis accurately evaluates module depth and identifies valid deepening opportunities.

What is the best way to communicate codebase refactoring candidates to my team?

The best way to communicate refactoring candidates is by sharing self-contained HTML reports. These visual reports use Mermaid diagrams to illustrate before/after architectural states, making deepening opportunities clear for team alignment.