improve-codebase-architecture

Scan repositories to identify and rank standards-backed architecture refactor opportunities.

345|9|Updated Jun 19, 2026
One-click install
npx skills add https://github.com/dmmulroy/skills --skill improve-codebase-architecture-dmmulroy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/dmmulroy/skills/tree/main/improve-codebase-architecture
Command: npx skills add https://github.com/dmmulroy/skills --skill improve-codebase-architecture-dmmulroy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you spot architecture problems in a codebase that create caller burden, weak boundaries, duplicated policy, poor test seams, or runtime friction. It turns broad code inspection into a focused scan for refactor opportunities grounded in shared coding standards.

Core Features & Use Cases

  • Standards-backed analysis: Loads the relevant design, boundaries, error-handling, and testing standards before judging a code area.
  • Evidence-first candidate ranking: Uses concrete files, call paths, interfaces, and tests to identify real leverage instead of vague cleanup ideas.
  • Architecture planning only: Produces ranked refactor candidates and recommends what to explore next without editing code or drafting a full implementation spec.
  • Use case: A team wants to understand why a module feels hard to extend, so the Skill scans the repository, isolates the friction, and returns the most valuable refactor directions.

Quick Start

Ask the skill to scan the chosen repository or directory and return a globally ranked list of standards-backed architecture refactor opportunities.

Frequently Asked Questions about improve-codebase-architecture

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

FAQPage Schema
How do I find high-leverage architecture refactors in a TypeScript codebase?

To find high-leverage architecture refactors, scan your repository for modules, boundaries, and call paths to identify concrete opportunities that reduce caller burden and tighten invariants without making code changes.

What is the best way to analyze code boundaries and reduce caller burden?

The best way to reduce caller burden is to run a planning-only repository scan that evaluates modules and call paths against your coding standards, returning ranked refactor candidates that target high-friction boundaries.

Can I use a code review to identify runtime seams and testing friction?

Yes, you can scan the repository to evaluate runtime seams and test interfaces against testing standards, isolating specific architectural friction points that make modules difficult to extend or validate.

Does architecture refactor analysis generate implementation plans and code changes?

No, architecture refactor analysis is planning-only and generates no code changes, tests, or implementation specs, focusing strictly on producing a ranked list of refactor opportunities and recommended next steps to explore.

When do I need an evidence-based architecture scan for my repository?

You need an evidence-based architecture scan when a module feels hard to extend and you want to isolate the exact friction points using concrete files, call paths, and interface evidence rather than vague cleanup ideas.

How do I align codebase refactoring candidates with existing coding standards?

To align refactoring candidates with coding standards, the scan loads your design, boundaries, error-handling, and testing standards before evaluating code areas, ensuring that identified refactor opportunities are backed by shared guidelines.