/balanced-coupling

name: balanced-coupling
description: >
  The Balanced Coupling model for software design. Use when: designing modular architectures,
  evaluating coupling between components, reviewing code modularity, deciding whether to split
  or merge modules/services, assessing integration patterns, classifying coupling as balanced
  or unbalanced, applying DDD strategic and tactical patterns, reasoning about cohesion vs
  coupling trade-offs, identifying distributed monolith risks, or explaining why a system
  is hard to change. Provides the three-dimensional framework (integration strength, distance,
  volatility) and the balance rule for making coupling decisions.
user-invocable: false

The Balanced Coupling Model

A comprehensive reference for understanding the Balanced Coupling model as described by Vlad Khononov. This document synthesizes the full model from the companion blog at coupling.dev, covering its foundations, dimensions, balancing mechanics, relationship to prior coupling models, and connections to domain-driven design.

---

1. Foundations: Why Coupling Matters

1.1 Coupling Is Not the Enemy

The term "coupling" has long been synonymous with bad design. The balanced coupling model challenges this assumption. According to the dictionary, coupling is simply a device for connecting parts. If a system is a set of components interacting to achieve a goal, then coupling is what connects those components and makes it possible to achieve those goals. **Coupling is what makes the value of a system greater than the sum of its parts.**

You cannot build a system out of fully independent components — that would go against the very definition of "system." The question is not whether to couple, but *how* to couple. Some forms of coupling lead to modularity; others create complexity. The balanced coupling model treats coupling not as a nuisance to eliminate but as a **design tool** to wield deliberately.

1.2 Complexity (via Cynefin)

The model adopts the Cynefin framework's definition of complexity:

• **Clear (Simple):** You make a change and know exactly what the outcome will be.
• **Complicated:** You don't know the outcome, but an expert does and you can consult them.
• **Complex:** The only way to determine the outcome is to make the change and observe what happens. Cause and effect can only be identified in hindsight.
• **Chaotic:** No identifiable relationship between actions and outcomes, even in hindsight.

In software design, **complexity** means a system where the outcomes of changes are unpredictable. The goal of modular design is to avoid situations where the effect of a change can only be identified in retrospect.

Crucially, **complexity is subjective** — it is a function of both system design and our cognitive limits:

complexity = f(system design, cognitive limits)

Studies suggest humans can hold only 4 +/- 1 units of information in working memory simultaneously. When the information required to make a change exceeds this cognitive capacity, the design is complex.

1.3 Modularity: The Opposite of Complexity

If complexity makes change outcomes unpredictable, modularity is its opposite. A modular design satisfies two criteria:

1. It is **clear what parts** of the system need to change. 2. The **outcome of the change** is clear and predictable.

Modularity extends a system's goals into the future. It doesn't mean preemptively implementing future requirements — that's impossible. It means making the implementation of *reasonable* future changes easy by minimizing the cognitive load required.

A system is a set of components interacting to achieve goals. Even a "big ball of mud" can achieve its current goals. Modular design extends the system's goals by ensuring it can *continue* to achieve goals as they evolve.

1.4 The Shared Cause

Complexity and modularity are contrasting concepts driven by the same fundamental cause: **coupling**. The way components are connected determines whether the system is modular or complex.

---

2. The Three Dimensions of Coupling

When two components are coupled, the connection between them — not the components themselves — is what determines modularity or complexity. The balanced coupling model evaluates this connection along **three dimensions**: integration strength, distance, and volatility.

2.1 Integration Strength (Knowledge)

Integration requires components to exchange **knowledge** about each other. The more knowledge is shared, the higher the probability that a change in one component will trigger cascading changes in others.

Rather than trying to "measure" knowledge quantitatively, the model **categorizes** types of knowledge. Each type involves significantly different amounts of shared knowledge. This is the **Integration Strength** model, which identifies four levels (from strongest/most knowledge to weakest/least):

Intrusive Coupling (Strongest)

Occurs when **private interfaces** or implementation details are used for integration — internal databases, private objects, undocumented APIs. We must assume **all knowledge** about a component's implementation is shared. Intrusive coupling is both **fragile** and **implicit** — the authors of the "intruded" component may not even know the integration exists.

Corresponds to **content coupling** (pathological coupling) in the classic module coupling model.

Functional Coupling

Shifts focus from *how* a component is implemented to *what* it implements: its **functional requirements**. Occurs when multiple components share knowledge of their business requirements and must change together when those requirements evolve.

An extreme case is **duplicated knowledge** — the same business rule implemented in both frontend and backend. If a specification change isn't reflected in both simultaneously, the system enters an inconsistent state.

Like intrusive coupling, functional coupling can be **implicit**: duplicated business logic in components th