improve-codebase-architecture

Detect shallow, tightly-coupled modules and propose domain-aligned refactoring opportunities.

1|Updated Apr 22, 2026
One-click install
npx skills add https://github.com/Herxinsasa/Skills-Collector --skill improve-codebase-architecture-herxinsasa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/Herxinsasa/Skills-Collector/tree/main/mattpocock-skills/skills/engineering/improve-codebase-architecture
Command: npx skills add https://github.com/Herxinsasa/Skills-Collector --skill improve-codebase-architecture-herxinsasa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common pain of working with codebases full of shallow, tightly-coupled modules that are hard to test, hard to maintain, and difficult for AI tools to navigate. It surfaces hidden architectural friction and proposes targeted refactors to turn shallow modules into deep, high-leverage ones, improving both developer productivity and AI navigability.

Core Features & Use Cases

  • Architectural Friction Detection: Scans codebases to identify shallow modules (where interface complexity nearly matches implementation complexity), tightly-coupled modules that leak across seams, and hard-to-test areas.
  • Domain-Aligned Recommendations: All suggestions use the project's existing domain language from CONTEXT.md and respect recorded architectural decisions (ADRs) to avoid conflicting with prior choices.
  • Use Cases: Ideal for refactoring legacy codebases, improving test coverage, consolidating redundant modules, and making codebases more navigable for both human developers and AI coding assistants.

Quick Start

Use the improve-codebase-architecture skill to scan the current project codebase and list the top 3 highest-impact deepening opportunities, aligned with the domain terms defined in the project's CONTEXT.md.

Frequently Asked Questions about improve-codebase-architecture

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

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

Identify shallow modules by scanning for areas where interface complexity nearly matches implementation complexity. This Skill detects tightly-coupled modules causing architectural friction and surfaces targeted deepening opportunities to improve testability and maintainability across legacy projects of any size.

What is module deepening and how does it improve codebase testability?

Module deepening is the process of turning shallow modules into deep, high-leverage ones by consolidating interface and implementation complexity. It improves testability by reducing tight coupling across architectural seams, making codebases easier to test and maintain for both developers and AI navigability.

Can I use architectural refactoring recommendations without breaking existing ADR alignment?

Yes, architectural refactoring recommendations respect recorded architectural decisions by tracking ADR conflicts. All deepening suggestions use existing domain language from CONTEXT.md to ensure proposed module consolidation aligns with prior architectural choices without introducing conflicting design patterns.

What's the best way to improve AI navigability for a tightly-coupled codebase?

Improve AI navigability by detecting tightly-coupled modules that leak across seams and applying targeted module deepening refactors. This Skill surfaces hidden architectural friction and delivers actionable opportunities to make the codebase more navigable for AI coding assistants and human developers.

Does this codebase architecture analysis work for projects of any scale?

Yes, codebase architecture analysis applies to projects of any size. It scans for shallow, tightly-coupled modules and hard-to-test areas regardless of scale, delivering domain-aligned deepening opportunities and interface design exploration tailored to the specific project context.