cohesion-coupling

Identify module boundaries to maximize cohesion and minimize coupling.

1|Updated Feb 18, 2026
One-click install
npx skills add https://github.com/rai-wtnb/clean-modularmonolith-go --skill cohesion-coupling
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: cohesion-coupling
Source: https://github.com/rai-wtnb/clean-modularmonolith-go/tree/main/.claude/skills/cohesion-coupling
Command: npx skills add https://github.com/rai-wtnb/clean-modularmonolith-go --skill cohesion-coupling

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps teams evaluate module boundaries to achieve high cohesion and loose coupling, reducing cross-module dependencies and refactoring complexity.

Core Features & Use Cases

  • Cohesion types and coupling types explained with practical refactoring guidelines.
  • Design patterns and heuristics for boundary decisions across modules and services.
  • Use cases include restructuring monolith components, before-after migration plans, and codebase audits.

Quick Start

Apply cohesion-coupling principles to assess and restructure a module's boundaries in your codebase.

Frequently Asked Questions about cohesion-coupling

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

FAQPage Schema
How do I identify module boundaries to fix low cohesion and tight coupling?

Restructure monolith components by assessing module boundaries and applying refactoring strategies. Generate before-after migration plans that enforce high cohesion and minimize cross-module dependencies to reduce refactoring complexity.

What are the different cohesion and coupling types in software architecture?

Cohesion and coupling types categorize how modules interact and group functionality within software architecture. Analyzing these types during codebase audits helps teams apply practical design heuristics to enforce clean module boundaries and reduce cross-module dependencies.

How do I refactor a monolith module into clean service boundaries?

Refactor monolith modules by evaluating existing boundaries and applying design patterns to separate services. Create before-after migration plans that enforce high cohesion and loose coupling, effectively reducing cross-module dependencies and long-term refactoring complexity.

Does this approach work for restructuring layered architectures?

Yes, this approach works for restructuring layered architectures by applying cohesion and coupling principles to evaluate and adjust module boundaries. It enforces consideration of practical design heuristics to guide boundary decisions across various common scenarios like monoliths and services.

When should I not use high cohesion and loose coupling for module design?

You should reconsider strictly enforcing high cohesion and loose coupling when a codebase audit reveals that heavily intertwined legacy logic makes immediate separation impractical. In such constraints, apply incremental refactoring strategies rather than attempting a full module boundary overhaul.