codebase-improve-architecture

Identify architectural friction in codebases and propose RFC-ready deepening opportunities for improved testability.

3|2|Updated Mar 23, 2026
One-click install
npx skills add https://github.com/wesleyegberto/software-engineering-skills --skill codebase-improve-architecture
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: codebase-improve-architecture
Source: https://github.com/wesleyegberto/software-engineering-skills/tree/main/plugins/architecture/skills/codebase-improve-architecture
Command: npx skills add https://github.com/wesleyegberto/software-engineering-skills --skill codebase-improve-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Identify architectural friction within a codebase and surface opportunities to deepen shallow modules for better testability and AI-navigability.

Core Features & Use Cases

  • Explore the codebase to surface friction points between modules and interfaces.
  • Present deepening opportunities with rationale and impact on testability.
  • Frame problem space for the chosen candidate to guide subsequent design work.
  • Generate RFC-ready proposals to initiate refactors and governance.

Quick Start

Initiate a codebase exploration session with the Agent tool to surface architectural friction and deepening opportunities.

Frequently Asked Questions about codebase-improve-architecture

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

FAQPage Schema
How do I identify architectural friction in my codebase to improve testability?▼

Identify architectural friction by exploring module boundaries and coupling within your codebase to surface opportunities to deepen shallow modules, which directly improves testability and AI-navigability.

What is a shallow module in software architecture and why does it reduce testability?▼

A shallow module in software architecture has poor boundary separation and high coupling, which creates friction and reduces testability; deepening these modules involves isolating logic to make components easier to test independently.

How do I generate an RFC-ready proposal for refactoring module boundaries?▼

Generate an RFC-ready proposal for refactoring module boundaries by framing the problem space of a chosen deepening candidate, providing rationale, and detailing the expected impact on testability and coupling for governance review.

Can I analyze module coupling and testability across different programming languages?▼

Yes, you can analyze module coupling and testability across different programming languages, because the architectural analysis focuses on universal module boundaries and friction points rather than language-specific syntax.

What is the best way to start a codebase exploration session for refactoring opportunities?▼

The best way to start a codebase exploration session is to initiate an Agent tool analysis to automatically surface architectural friction points and present deepening opportunities with their rationale and testability impact.