improve-codebase-architecture

Identify architectural friction and propose module deepening candidates in codebases.

1|Updated May 20, 2025
One-click install
npx skills add https://github.com/vessux/dotfiles --skill improve-codebase-architecture-vessux
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/vessux/dotfiles/tree/main/umbel/skills/pocock/improve-codebase-architecture
Command: npx skills add https://github.com/vessux/dotfiles --skill improve-codebase-architecture-vessux

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Identify architectural friction and opportunities to deepen modules into more-leverage, testable interfaces in a codebase.

Core Features & Use Cases

  • Surface friction points and propose concrete deepening candidates that increase interface leverage and locality.
  • Align refactors with domain language in CONTEXT.md and ADR decisions to maintain architectural consistency.
  • Support AI-navigable codebases by clarifying seams, adapters, and test surfaces for maintainability.

Quick Start

Provide a deepening candidate for your current project by describing the target module, the seam location, and a high-level refactor plan.

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 architectural friction in my codebase for refactoring?

Surface architectural friction by analyzing tightly coupled modules to find deepening opportunities that increase interface leverage and locality, guiding you through a Discovery-Grilling loop to generate concrete refactor candidates.

What are seams in codebase architecture and when do I need them?

Seams are adapter locations in a codebase where behavior can be altered without editing in that place. You need them when consolidating tightly coupled modules to improve testability and create AI-navigable code surfaces.

How do I refactor tightly coupled modules to improve testability?

Refactor tightly coupled modules by proposing concrete deepening candidates that increase interface leverage, clarifying seams and test surfaces to align with domain language and maintain architectural consistency.

Can I align my refactor plan with existing domain language and ADR decisions?

Yes, you can align refactors with domain language documented in CONTEXT.md and ADR decisions to maintain architectural consistency, ensuring deepening candidates satisfy domain-aligned terminology and evaluation criteria.

What's the best way to make a codebase AI-navigable during modernization?

Make a codebase AI-navigable during modernization by clarifying seams, adapters, and test surfaces for maintainability, applying the Discovery-Grilling loop to evaluate deepening opportunities across the repository.

When should I not use architectural deepening on my codebase?

Avoid architectural deepening when modules are not tightly coupled or lack defined seam locations, as the process requires identifiable friction points and a high-level refactor plan to successfully increase interface leverage.