deep-modules

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.

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.

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.

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.

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.

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.