modularity-review

Analyzes codebase modularity using the Balanced Coupling model to identify design issues.

9|Updated Jul 17, 2026
One-click install
npx skills add https://github.com/Yassimba/loom --skill modularity-review-yassimba
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: modularity-review
Source: https://github.com/Yassimba/loom/tree/main/skills/modularity-review
Command: npx skills add https://github.com/Yassimba/loom --skill modularity-review-yassimba

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Codebases often suffer from hidden coupling problems—tight integration across distant components, distributed monolith risks, and areas where changes are unexpectedly expensive. This Skill systematically reviews a codebase's modularity using the Balanced Coupling model, turning vague architectural discomfort into a concrete, prioritized list of design issues. ## Core Features & Use Cases - Balanced Coupling Analysis: Evaluates every component integration across three dimensions—strength, distance, and volatility—using the formula BALANCE = (STRENGTH XOR DISTANCE) OR NOT VOLATILITY. - Guided Domain Discovery: Reads your docs and code first, then asks targeted one-at-a-time questions about domain classification, team ownership, and pain points to fill gaps that affect the assessment. - Prioritized Review Output: Produces a modularity review in Markdown and HTML that flags only integrations that are both unbalanced and volatile, grounded in specific code observations. - Use Case: You suspect your microservices are actually a distributed monolith. Run this Skill to map integrations, identify intrusive coupling across service boundaries in volatile domains, and get a review explaining which integrations to fix first and why. ## Quick Start Use the modularity-review skill to analyze this codebase for coupling problems and produce a modularity review.

Frequently Asked Questions about modularity-review

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

FAQPage Schema
How do I review a codebase for coupling problems?

Use the Balanced Coupling model: map each integration between components, classify its strength (intrusive, functional, model, or contract), measure distance (module, service, team boundaries), and assess domain volatility. Flag integrations that are unbalanced and volatile as priority issues.

What is the Balanced Coupling model in software architecture?

The Balanced Coupling model by Vlad Khononov evaluates integrations using three dimensions: strength, distance, and volatility. The balance rule states BALANCE = (STRENGTH XOR DISTANCE) OR NOT VOLATILITY, meaning high-strength coupling is only safe at low distance or in stable domains.

How do I detect a distributed monolith in microservices?

Look for high-strength coupling (shared databases, implicit business rules, intrusive integration) combined with high distance (separate services or teams) in volatile domains. These integrations cause cascading changes and expensive deployments, which are the signature symptoms of a distributed monolith.

Does this analysis work on any codebase or only microservices?

It works on any codebase, including monoliths, modular monoliths, and microservices. You can scope the analysis to the entire codebase, a specific directory, or named components, and the model evaluates distance at module, service, and system levels.

When should I not decompose tightly coupled components?

Avoid decomposition when coupling strength is still high, because splitting components increases distance and worsens the imbalance. Only decompose when strength is low enough to support the added distance, or when lifecycle coupling is the primary bottleneck.