improve-codebase-architecture

Explore repository structure and propose deepening refactors as RFCs.

1|Updated Jan 6, 2026
One-click install
npx skills add https://github.com/Levezze/devkit --skill improve-codebase-architecture-levezze
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/Levezze/devkit/tree/main/skills/improve-codebase-architecture
Command: npx skills add https://github.com/Levezze/devkit --skill improve-codebase-architecture-levezze

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It identifies architectural friction that makes a codebase hard to understand, refactor, and test by finding shallow, tightly-coupled modules whose seams hide bugs.

Core Features & Use Cases

  • AI-driven codebase exploration: navigates naturally to locate places where understanding requires bouncing across many files or where integration seams create risk.
  • Deepening opportunities discovery: produces a numbered set of candidates that focus on improving testability by deepening shallow modules.
  • Refactoring RFC generation: guides the user through framing constraints and then designs multiple interface options before drafting a GitHub issue RFC using the provided template.
  • Testing-first architectural focus: classifies dependencies (in-process, local-substitutable, ports & adapters, external mock) to support boundary-focused tests instead of brittle internal layering.

Quick Start

Use it to improve architecture when you want the AI to explore your repository and propose deepening refactors as issue-ready RFCs.

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 tightly-coupled modules in my codebase to improve testability?

To improve testability, you can explore your repository structure to locate tightly-coupled modules. The system organically navigates the codebase to categorize dependencies like in-process, local-substitutable, and ports & adapters, identifying architectural friction where understanding requires bouncing across many files.

What is the best way to plan refactoring boundaries for shallow modules?

Planning refactoring boundaries for shallow modules involves identifying coupling seams and producing a numbered set of deepening candidates. This approach focuses on improving testability by designing multiple radically different interface options to separate external mocks from internal layering.

How do I generate an RFC for a codebase refactoring proposal?

Generating a refactoring RFC involves framing constraints and designing multiple interface options before drafting a GitHub issue. The system guides you through this process using an issue template to propose deepening refactors that address architectural friction.

When should I use ports and adapters to support boundary-focused tests?

You should use ports and adapters to support boundary-focused tests when integration seams create risk and brittle internal layering hides bugs. Categorizing dependencies into local-substitutable and external mock types helps isolate architectural friction and makes the codebase navigable.

Can I use this to explore repository structure without writing tests first?

Yes, you can use it to explore repository structure without writing tests first. It performs AI-driven codebase exploration to locate areas where understanding requires bouncing across files, producing refactoring candidates before any test implementation begins.