skills.rest
mrmtsuruya
mrmtsuruyaCOMMUNITY
Explore all skills by this author →
GitHub

improve-codebase-architecture

Identify and propose codebase deepening opportunities to improve architecture and testability.

Updated Aug 23, 2026
Search Tags:#refactoring#testability#deepening#codebase architecture#AI navigability
One-click install
npx skills add https://github.com/mrmtsuruya/hermes-backup --skill improve-codebase-architecture-mrmtsuruya
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/mrmtsuruya/hermes-backup/tree/main/skills/improve-codebase-architecture
Command: npx skills add https://github.com/mrmtsuruya/hermes-backup --skill improve-codebase-architecture-mrmtsuruya

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill identifies and proposes deepening opportunities in a codebase, improving its architecture, testability, and AI navigability.

Core Features & Use Cases

  • Deepening Opportunities: Surface architectural friction and suggest refactors to turn shallow modules into deep ones.
  • Domain Language: Uses the domain language in CONTEXT.md and architectural decisions in docs/adr/.
  • Use Case: When a user wants to improve architecture, find refactoring opportunities, or consolidate tightly-coupled modules.

Quick Start

Use the improve-codebase-architecture skill to explore deepening opportunities in your codebase.

Frequently Asked Questions about improve-codebase-architecture

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

FAQPage Schema
How do I identify refactoring opportunities to improve codebase architecture?▼

Codebase architecture improves by identifying deepening opportunities that surface architectural friction. It proposes refactors to turn shallow modules into deep ones, enhancing testability and AI navigability.

What is a deepening opportunity in software architecture?▼

A deepening opportunity identifies architectural friction to turn shallow modules into deep ones. It applies domain language and architectural decisions to consolidate tightly-coupled modules and improve testability.

Can I use architectural decisions in docs/adr to guide codebase refactoring?▼

Yes, codebase refactoring can use architectural decisions in docs/adr to guide the process. The analysis applies these decisions alongside domain language from CONTEXT.md to accurately propose deepening opportunities.

Does improving codebase architecture require exploring the entire codebase?▼

Improving codebase architecture requires exploring the codebase to analyze architectural friction. This exploration is necessary to accurately identify deepening opportunities and propose effective refactoring actions.

What is the best way to find refactoring opportunities in tightly-coupled modules?▼

The best way to find refactoring opportunities in tightly-coupled modules is to analyze architectural friction. By identifying deepening opportunities, you can consolidate these modules into deep, testable structures.

When should I not use deepening opportunities for architecture refactoring?▼

You should avoid deepening opportunities for architecture refactoring when the codebase lacks established domain language in CONTEXT.md or architectural decisions in docs/adr, as these are required to propose accurate structural improvements.

Related Skills

Explore More Software Engineering Skills→
ralvarezdevralvarezdev
3

improve-codebase-architecture

Identify shallow modules and propose seam-based interface deepening refactors.

Community
Advanced
MichaelSolatiMichaelSolati

improve-architecture

Identify shallow, tightly-coupled modules and propose deep module refactors.

Community
Advanced
guaderramaguaderrama

improve-codebase-architecture

Propose refactoring strategies that transform shallow modules into deep ones.

Community
Advanced
wesleyegbertowesleyegberto
3

codebase-improve-architecture

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

Community
Advanced