Callers use long dotted access paths to walk through one object to reach another's data — `order.customer.address.street` exposes every intermediate boundary.
The agent finds long dotted access paths through several object hops; renaming any intermediate field silently breaks every caller.
Callers ask the closest object for what they want; the object delegates internally without exposing its collaborators.
Callers reach for the wrapper's methods directly; the agent reads one type signature instead of walking the delegate chain to predict what the call returns.
Before the refactoring
const street = order.customer.address.street;
After the refactoring
// inside Order: customerStreet() { return this.customer.address.street; }const street = order.customerStreet();
Every link in the chain is a coupling point; renaming any intermediate field breaks every caller; consumers depend on the full graph shape.
Every link in the chain is a coupling point the agent holds in working memory; refactoring any intermediate shape requires updating every chain access.
Adds a passthrough method on the parent for every delegated operation — only worth it for operations that are repeated across consumers.
Each hidden delegate adds a passthrough method on the host; for chains used in one place the passthrough is overhead the agent now maintains in two places.
Encapsulation tightens; intermediate objects can change shape without breaking callers.
Callers read one type's methods to reach the delegate's behavior; the delegate's shape changes without breaking caller code, because the wrapper's signature is the only contract the agent's generated code depends on.
Wrapping every dotted access in a passthrough — including chains used only once where the wrapper adds cost without removing real coupling.
Wrapping every dotted chain in passthroughs migrates the chain from call sites into the host's surface — the agent now wades through a wall of delegations to find real behavior.