improve-codebase-architecture

Analyze codebase modules and generate module-deepening RFCs for GitHub issues.

2|Updated Mar 24, 2026
One-click install
npx skills add https://github.com/AmbitionsXXXV/Etyon --skill improve-codebase-architecture-ambitionsxxxv
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/AmbitionsXXXV/Etyon/tree/main/.agents/skills/improve-codebase-architecture
Command: npx skills add https://github.com/AmbitionsXXXV/Etyon --skill improve-codebase-architecture-ambitionsxxxv

SYSTEM DOCUMENTATION & REQUIREMENTS

## What problem does it solve? Surface architectural friction in large codebases and identify opportunities to deepen shallow modules to boost testability and AI-navigability.

## Core Features & Use Cases

  • Surface coupling signals across modules and interfaces.
  • Propose module-deepening RFCs and RFC templates for GitHub issues.
  • Prioritize changes that improve testability, maintainability, and boundary clarity.

### Quick Start Begin by exploring the codebase to surface architectural friction and propose deepening refactors as 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 analyze a large codebase to improve testability and system design?

Surface architectural friction by exploring your large codebase to identify shallow modules and cross-module coupling signals. You can then propose module-deepening refactors to boost testability, maintainability, and boundary clarity across the system.

What is a shallow module in codebase architecture and why does it matter?

A shallow module in codebase architecture is a component that hides little implementation detail, creating cross-module coupling and friction. Deepening these modules improves testability, AI-navigability, and overall architectural clarity.

How do I plan a refactor for moderately large codebases with cross-module dependencies?

Plan a codebase refactor by generating module-deepening candidates and framing interfaces to resolve cross-module dependencies. This approach prioritizes changes that improve testability and boundary clarity, culminating in RFC-driven governance via GitHub Issues.

Can I use GitHub Issues for RFC-driven governance when proposing architecture refactors?

Yes, you can use GitHub Issues for RFC-driven governance by proposing module-deepening RFCs using provided templates. This allows you to track architectural changes, prioritize testability improvements, and manage boundary design decisions directly in your repository.

Does this approach work for analyzing AI-navigability in large codebases?

Yes, analyzing AI-navigability in large codebases is a core focus of this approach. By deepening shallow modules and clarifying architectural boundaries, the system becomes significantly easier for AI to navigate and understand.

What is the best way to surface coupling signals across modules and interfaces?

The best way to surface coupling signals across modules is to analyze the codebase to identify friction points and shallow modules. This reveals cross-module dependencies and informs interface framing to improve architectural clarity.