Duplicate copies of a logically-single entity scattered across the codebase — every order carries its own Customer copy that should be the shared customer.
Duplicate copies of a logically-single entity scattered across the codebase; the agent updating the entity must find and update every copy consistently.
Duplicate copies of a logically-single entity collapse into one shared object that everyone references.
The entity exists once; the agent reasons about one canonical object referenced everywhere.
Before the refactoring
// every order carries its own Customer copyorders.forEach(o => o.customer = { name: 'Acme' });
After the refactoring
const acme = customerRepository.find('Acme');orders.forEach(o => o.customer = acme);
Updates to the entity must touch every copy; storage bloats; identity becomes ambiguous (which copy is the canonical one?).
The agent must coordinate updates across every copy; identity becomes ambiguous and the agent can't tell which copy is canonical.
Sharing introduces the question 'who owns this?' — make sure the lifetime and visibility of the shared reference are well-defined.
Sharing references introduces lifetime and visibility ambiguities (who owns this? when does it get freed?) the agent must reason about; the original value-copies sidestepped this.
Updates to the entity are visible everywhere; storage shrinks; identity becomes meaningful again.
Updates land in one place; storage shrinks; the agent reasons about the entity as a single referent with meaningful identity.
Sharing references without clear ownership — introduces lifetime and visibility ambiguities (who owns this? when does it get freed?) that the original value-copies hid.
Sharing references without explicit ownership creates lifetime ambiguities the agent must model — the cure introduces a different category of bug than the original duplication.