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.