skills.rest
SamyakJhaveri
SamyakJhaveriCOMMUNITY
Explore all skills by this author →
GitHub

improve-codebase-architecture

Identify shallow modules and generate an HTML report of deepening candidates.

Updated Jul 2, 2026
Search Tags:#architecture#refactoring#testability#adr#modularity#domain-language
One-click install
npx skills add https://github.com/SamyakJhaveri/loam --skill improve-codebase-architecture-samyakjhaveri
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/SamyakJhaveri/loam/tree/main/seed/.claude/skills/improve-codebase-architecture
Command: npx skills add https://github.com/SamyakJhaveri/loam --skill improve-codebase-architecture-samyakjhaveri

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Surface architectural friction and surface deepening opportunities to transform shallow modules into deep ones. The aim is to improve testability, AI-navigability, and maintainable locality.

Core Features & Use Cases

  • Explore shallow modules and identify seams where depth can be increased.
  • Propose domain-aligned deepening candidates using DOMAIN.md vocabulary and ADR decisions.
  • Generate a self-contained HTML report with diagrams and actionable guidance.
  • Provide a prioritized plan for refactoring that preserves behaviour and improves locality.

Quick Start

Ask the agent to generate a prioritized list of deepening candidates for my 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 shallow modules and improve codebase architecture for better testability?▼

Improving codebase architecture involves identifying deepening opportunities to convert shallow modules into deep ones. This refactoring process uses domain vocabulary and ADR decisions to surface cohesive candidates for consolidation, directly improving testability and maintainable locality.

What is the best way to refactor shallow code into deep modules?▼

The best way to refactor shallow code into deep modules is by analyzing the codebase using DOMAIN.md vocabulary and ADR decisions. This surfaces cohesive consolidation candidates and produces a prioritized, behavior-preserving plan that improves locality and AI-navigability.

How do I generate a visual report for codebase refactoring candidates?▼

You generate a visual report for refactoring candidates by analyzing your codebase for deepening opportunities. The tool produces a self-contained HTML report featuring before/after visuals for each candidate, a top-priority pick, and actionable guidance for follow-up exploration.

Do I need ADR decisions and DOMAIN.md files to analyze modularity?▼

You need ADR decisions and DOMAIN.md files to analyze modularity because the architectural analysis operates across the codebase using this specific domain vocabulary. These inputs ensure proposed deepening candidates are domain-aligned and respect prior architectural decisions.

When should I not use deep module refactoring on my codebase?▼

Avoid deep module refactoring when your priority is rapid feature delivery over architectural friction reduction. This approach targets testability and maintainable locality improvements, requiring behavior preservation during consolidation which may slow immediate feature development.

Related Skills

Explore More Software Engineering Skills→
alexandremendoncaalvaroalexandremendoncaalvaro
1

ad-grill-me

Analyze code and documentation to clarify ambiguous project requirements.

Community
Advanced
mpsuessermpsuesser

improve-codebase-architecture

Identify shallow modules and architectural friction to improve codebase locality and leverage.

Community
Advanced
opensage-agentopensage-agent
113

improve-codebase-architecture

Analyzes module structure and proposes deep redesigns for fragmented codebases.

Official
Advanced
sanity-iosanity-io
6.3k

improve-codebase-architecture

Identify shallow modules and propose RFC-style refactors for codebases.

Official
Intermediate