Verified:GitHub

mp-architecture-review

Identify architectural friction and testability gaps into deep-module refactor proposals.

1|Updated Feb 7, 2026

Search Tags:#refactoring #test strategy #interface design #architecture review #ports and adapters #deep modules #github rfc

Ready to run

npx skills add https://github.com/MartinoPolo/mpx-claude-code --skill mp-architecture-review

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: mp-architecture-review
Source: https://github.com/MartinoPolo/mpx-claude-code/tree/main/skills/mp-architecture-review
Command: npx skills add https://github.com/MartinoPolo/mpx-claude-code --skill mp-architecture-review

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps you identify architectural friction in a codebase and convert that friction into concrete, testable refactor proposals you can implement as GitHub RFC issues.

Core Features & Use Cases

Deep-module refactor guidance: Surfaces places where the interface is shallow, tightly coupled, or hard to test, then frames deepening opportunities.
Dependency-category-based planning: Classifies dependencies (in-process, local-substitutable, ports & adapters, true external) to drive the right refactor/testing strategy.
Boundary-focused testing impact: Replaces brittle shallow-module tests with interface-boundary tests to make refactors safer and more maintainable.
RFC issue creation: Produces an issue body using the repository’s RFC template so the plan is ready for implementation.

Quick Start

Use the mp-architecture-review skill to review architecture, propose deepening candidates, and generate a refactor RFC issue from the friction you find.

Frequently Asked Questions about mp-architecture-review

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

FAQPage Schema

How do I identify architectural friction and turn it into a refactor RFC?▼

To identify architectural friction and turn it into a refactor RFC, analyze the codebase for tightly coupled seams and testability gaps, then convert those deepening opportunities into an actionable GitHub RFC issue using a repository template.

When do I need deep modules for interface design refactoring?▼

You need deep modules for interface design refactoring when your current interfaces are shallow, tightly coupled, or hard to test. Deepening these modules improves dependency handling and increases overall system maintainability.

How do I plan boundary-level tests for tightly coupled code?▼

To plan boundary-level tests for tightly coupled code, classify dependencies into categories like in-process, local-substitutable, and ports and adapters. This strategy replaces brittle shallow-module tests with safer interface-boundary tests.

What is the best way to untangle tightly coupled dependencies using ports and adapters?▼

The best way to untangle tightly coupled dependencies using ports and adapters is to classify dependencies by category and design radically different interface options. This frames clear deepening opportunities for your refactor proposal.

Can I generate a GitHub RFC issue directly from my architecture review?▼

Yes, you can generate a GitHub RFC issue directly from your architecture review. The process produces an issue body using your repository's specific RFC template, making the deep-module refactor plan ready for immediate implementation.

Does this approach work for dependency-category-based planning in any software codebase?▼

Yes, dependency-category-based planning works for any software codebase by classifying dependencies into in-process, local-substitutable, ports and adapters, and true external categories to drive the appropriate refactor and testing strategy.