improve-codebase-architecture

Analyze codebases for architectural friction and rank deepening opportunities.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/meisijiya/ohMeisijiyaCode --skill improve-codebase-architecture-meisijiya
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/meisijiya/ohMeisijiyaCode/tree/main/skills/improve-codebase-architecture
Command: npx skills add https://github.com/meisijiya/ohMeisijiyaCode --skill improve-codebase-architecture-meisijiya

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you spot architectural friction in a repository and turn shallow, hard-to-test modules into deeper ones with clearer seams and better locality.

Core Features & Use Cases

  • Architecture Review: Analyze the codebase for tight coupling, pass-through modules, and places where complexity is spread across too many files.
  • Refactoring Prioritization: Rank the most valuable deepening opportunities so you know what to change first.
  • Report Generation: Produce a self-contained HTML review with before-and-after visuals, concise findings, and a top recommendation.
  • Use Case: A team wants to reduce test pain and simplify future changes; this Skill identifies the best module to deepen and explains why it matters.

Quick Start

Ask the skill to review the repository and generate a self-contained architecture report with the strongest deepening candidates.

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 tight coupling and shallow modules for codebase refactoring?

Codebase refactoring identifies tight coupling and shallow modules by analyzing architectural friction, surfacing pass-through modules, and ranking deepening opportunities by strength to prioritize changes. It targets modules that feel shallow or hard to test.

What is the best way to plan refactoring to improve codebase testability and locality?

The best way to improve codebase testability and locality is to perform a module testability analysis that finds architectural seams, reduces test pain, and proposes deepening opportunities with clear before-and-after diagrams.

How do I generate an architecture review report with before and after diagrams?

You generate an architecture review report by running a repository analysis that produces a self-contained HTML report, featuring before-and-after Mermaid diagrams, concise findings, and a top recommendation for refactoring.

Can I use architecture review for repository reviews and seam identification without external dependencies?

Yes, architecture review supports repository reviews and seam identification directly, requiring only domain glossary and ADR awareness to surface friction, operating with no external dependencies.

Why does my codebase architecture feel shallow and how do I find deep refactor candidates?

Codebase architecture feels shallow when complexity is spread across too many files with poor locality, requiring an architectural friction analysis to surface and rank the strongest deep refactor candidates.

What are the limitations of using automated architecture review for module testability analysis?

Automated architecture review for module testability analysis requires domain glossary and ADR awareness to function accurately, meaning its recommendations are limited by the provided context and repository structure.