skills.rest
hschne
hschneCOMMUNITY
Explore all skills by this author →
Website𝕏@hschnedlitzGitHub

architecture

Identify shallow modules and architectural friction in codebases.

1|Updated Apr 14, 2026
Search Tags:#architecture#refactoring#testability#codebase analysis#module deepening#seam design
One-click install
npx skills add https://github.com/hschne/pi-stuff --skill architecture-hschne
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture
Source: https://github.com/hschne/pi-stuff/tree/main/skills/architecture
Command: npx skills add https://github.com/hschne/pi-stuff --skill architecture-hschne

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill eliminates the guesswork of improving codebase architecture by systematically identifying shallow modules, tight coupling, and architectural friction that reduce testability, increase maintenance overhead, and make code harder for both developers and AI tools to navigate.

Core Features & Use Cases

  • Shallow Module Detection: Uses the deletion test and standardized architecture vocabulary to identify modules that move complexity around instead of hiding it.
  • Visual HTML Report Generation: Produces a self-contained, interactive report with before/after diagrams, candidate prioritization, and a top recommendation for the most impactful refactor.
  • Interactive Grilling Loop: Guides a structured conversation to explore constraints, dependencies, and interface design for chosen refactoring candidates.
  • Use Case: An engineering team struggling with untestable, tightly-coupled legacy code can use this Skill to surface concrete, prioritized refactoring opportunities that improve test coverage and reduce long-term maintenance costs.

Quick Start

Ask the AI to analyze your project's codebase for architectural friction and generate a prioritized report of refactoring opportunities to deepen shallow modules and improve testability.

Frequently Asked Questions about 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?▼

This Skill detects shallow modules by applying the deletion test and standardized architecture vocabulary to find modules that move complexity rather than hide it. It generates a self-contained HTML report prioritizing refactoring candidates to deepen those modules.

How can I find refactoring opportunities to improve code testability and reduce tight coupling?▼

This Skill systematically identifies architectural friction and tight coupling in your codebase to enable targeted refactors. It produces an HTML report with prioritized candidates, dependency classification, and before/after diagrams to improve testability.

What is the best way to analyze legacy code for architectural friction?▼

Analyzing legacy code for architectural friction requires identifying shallow modules and tight coupling systematically. This Skill outputs a prioritized HTML report of refactoring candidates with before/after diagrams and dependency classifications to guide codebase improvements.

Does this architectural analysis require any specific dependencies or setup?▼

No external dependencies are required to use this architectural analysis Skill. It works directly on your codebase to identify shallow modules and outputs a self-contained HTML report with prioritized refactoring candidates and before/after diagrams.

Can I use this to generate visual diagrams of codebase refactors before and after?▼

Yes, this Skill generates a self-contained HTML report containing before/after diagrams for prioritized refactoring candidates. The report visually demonstrates how to deepen shallow modules and clarify seams to reduce tight coupling.

How do I explore constraints and interface design for a specific refactoring candidate?▼

This Skill uses an interactive grilling loop to explore constraints, dependencies, and interface design for chosen refactoring candidates. This structured conversation helps engineering teams evaluate targeted deepening refactors before implementation.

Related Skills

Explore More Software Engineering Skills→
r3dlexr3dlex
2

improve-codebase-architecture

Analyze codebases for structural friction and shallow modules.

Community
Advanced
UniFormTSUniFormTS
2

improve-codebase-architecture

Identify shallow modules and generate HTML reports with before/after refactor diagrams.

Official
Advanced
safzanpiranisafzanpirani
1

improve-codebase-architecture

Identify architectural friction and write RFCs for module deepening refactors.

Community
Advanced
VictorSmaniottoVictorSmaniotto

code-analyzer

Analyze PHP code for smells, complexity, duplications, and pattern violations.

Community
Intermediate