improve-codebase-architecture

Analyze domain language and ADRs to identify codebase deepening opportunities.

Updated Nov 16, 2022
One-click install
npx skills add https://github.com/kos3nz/dotfiles --skill improve-codebase-architecture-kos3nz
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/kos3nz/dotfiles/tree/main/.config/agents/skills/improve-codebase-architecture
Command: npx skills add https://github.com/kos3nz/dotfiles --skill improve-codebase-architecture-kos3nz

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Surface architectural friction and identify high-leverage deepening opportunities in a codebase, informed by the project's domain language and ADRs.

Core Features & Use Cases

  • Explore domain glossary alignment and ADR decisions to locate shallow modules and seams.
  • Propose concrete deepening candidates with explainable locality and leverage metrics.
  • Assist in planning and iteration through a grilling loop with user feedback to converge on a robust refactor path.

Quick Start

Analyse the codebase domain language and ADRs to surface a deepening candidate for architecture refactoring.

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 in a codebase with shallow module interfaces?

Deepening opportunities in tightly coupled modules are identified by analyzing domain glossary alignment and ADR decisions to locate shallow architectural seams. This guides exploration of concrete candidates with explainable locality and leverage metrics.

What is architectural deepening and when should I apply it to my software architecture?

Architectural deepening is the process of uncovering friction in shallow interfaces to propose robust structural refactor paths. You should apply it when analyzing domain language and ADRs to surface high-leverage opportunities in tightly coupled codebases.

How do I use ADRs and CONTEXT.md vocabulary to plan a codebase refactoring strategy?

Use ADRs and CONTEXT.md vocabulary to align domain language with architectural decisions, identifying deepening candidates and iterating through a grilling loop. This convergence process yields a robust, validated codebase refactoring strategy.

Can I evaluate the leverage and locality of a proposed architecture refactoring before implementation?

Yes, you can evaluate proposed refactorings by formatting deepening candidates with explainable locality and leverage metrics. This assessment is supported by analyzing ADR considerations and domain language alignment within your existing codebase architecture.

What is the best way to refactor tightly coupled modules without breaking domain language consistency?

The best way to refactor tightly coupled modules while maintaining domain consistency is to align changes with CONTEXT.md and LANGUAGE.md vocabulary. Propose deepening candidates iteratively using a grilling loop to validate architectural leverage and locality.

Does this codebase analysis approach work without existing Architecture Decision Records?

While analyzing ADR decisions is a core feature for locating shallow modules, the approach also relies heavily on CONTEXT.md and domain language vocabulary. Lacking ADRs may limit the depth of architectural friction surfacing and deepening candidate accuracy.