Functions taking five, six, or more parameters — especially when several travel together as a logical group. The signature stops communicating intent; readers learn which arguments belong together and what each one means by reading the function body or by trial and error at the call site. The reader's mental effort per call scales with parameter count.
Related parameters travel together as one well-named value object the function and its callers refer to by domain meaning. The signature becomes self-documenting at the call site; reviewers see the domain concept rather than a list of primitives they must compose mentally. The reader's comprehension cost per call drops to the size of the object's name.
Smellier version
function book(name, email, street, city, zip, depart, arrive, seat) {// ...}
Fresher version
function book(traveler, address, trip) {// ...}
Callers must remember argument order and meaning; refactoring has the blast radius of every call site. Adding a new parameter is a coordination exercise across the team — every caller pays verification cost to confirm the new argument lands in the right slot, and silent positional swaps escape review when the types coincidentally line up.
Introducing a parameter object adds a class the team must learn; if the bundle isn't meaningful as a concept, the type adds accidental complexity without clarity. The object's contract becomes the shared invariant every caller and callee rely on; if the bundle is wrong, the enhancement cost of adding parameter variations spikes.
Adding a related field is one type change instead of touching every signature; intent is named at the call site. The team's maintenance cost drops because the parameter object becomes the locus of evolution for the bundle; downstream callers compose against the type rather than against the individual slots.
Bundling parameters that don't actually travel together — synthetic value objects that exist only to shorten signatures, with no domain coherence behind them. The reader pays the cognitive load of a leaky abstraction that hides the real shape of the call without earning a corresponding comprehension cost drop. The bundle obscures intent rather than revealing it.