deep-modules

Identify shallow modules and reduce unnecessary interface complexity in software designs.

11|Updated Feb 25, 2026

Search Tags:#code review #refactoring #abstraction #module design #interface complexity #classitis #pass-through methods

Ready to run

npx skills add https://github.com/codybrom/clairvoyance --skill deep-modules

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: deep-modules
Source: https://github.com/codybrom/clairvoyance/tree/main/skills/deep-modules
Command: npx skills add https://github.com/codybrom/clairvoyance --skill deep-modules

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps identify modules whose interfaces are too complex for the functionality they provide, reducing unnecessary caller knowledge, pass-through code, and over-decomposition.

Core Features & Use Cases

Depth Analysis: Compare interface complexity with the implementation work performed behind it.
Classitis Detection: Find clusters of thin classes, decorator chains, and shallow abstractions that should be merged or deepened.
Pass-Through Auditing: Identify forwarding methods and variables that add interface cost without meaningful behavior.
Use Case: Apply the Skill during a code review to determine whether a new service wrapper should be merged with its dependency or redesigned as a deeper abstraction.

Quick Start

Use the deep-modules skill to review the specified file or module for shallow interfaces, classitis, and pass-through methods.

Frequently Asked Questions about deep-modules

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

FAQPage Schema

How do I identify shallow modules and reduce interface complexity in my codebase?▼

To identify shallow modules, compare interface complexity against the actual implementation work performed behind it. Look for thin abstractions, pass-through methods, and forwarding variables that add interface cost without delivering meaningful behavior to callers.

What is classitis and how do I detect thin class clusters during a code review?▼

Classitis refers to unnecessary over-decomposition into thin classes and shallow abstractions. Detect it by finding clusters of decorator chains or wrapper classes that should be merged or deepened to reduce the coordination burden on callers.

How do I audit pass-through methods and forwarding variables in software designs?▼

Audit pass-through methods by tracing forwarding calls and variables that simply pass arguments to another module without adding logic. These methods increase interface cost without providing meaningful behavior, making them prime candidates for elimination during refactoring.

Can I use this module design analysis for refactoring decorator chains and API wrappers?▼

Yes, you can apply interface depth analysis to classes, functions, APIs, wrappers, and decorator chains. It evaluates implementation scope and informal interface requirements to determine if abstractions should be merged or redesigned as deeper modules.

When should I merge service wrappers with their dependencies instead of keeping them separate?▼

You should merge service wrappers with dependencies when the wrapper acts as a shallow pass-through abstraction. If the interface complexity exceeds the implementation work performed, merging or redesigning it as a deeper module reduces unnecessary caller knowledge and coordination.

What's the best way to evaluate interface depth and decide whether to deepen a module?▼

Evaluate interface depth by comparing the knowledge a caller must possess against the implementation scope hidden behind it. If callers are coordinating too many small abstractions or defaults, deepening the module or merging abstractions simplifies the overall software design.