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.
A signature with so many positional parameters that the agent has to read the function definition into the context window before generating each invocation. The signature alone underspecifies the call; the agent must consult either the function body or recent call-site examples to know which positional slot corresponds to which domain meaning.
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.
Each parameter is a domain concept the agent recognizes, or part of a named object the agent passes through without unpacking. The signature carries enough type and naming signal that the agent generates correct invocations from the type information alone; per-call retrieval cost drops to zero in the common case.
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.
Every call site is a chance to misorder arguments or miss one; even with the type checker, the agent pays retrieval cost on every invocation. Coincidentally-typed adjacent parameters mean even type-checked code can ship with the agent's positional swap intact — a silent bug class the agent can't catch without completeness-check cost across every call.
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.
A new parameter object adds a class the agent loads to construct values; for one-use cases the token cost is pure overhead. The agent pays one extra read on every invocation that constructs the object and one extra read on every read of the object's shape — the abstraction must justify these costs by being reused enough to amortize them.
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.
Parameters bundled into a typed object are matched by name at every call site; the type checker catches missed fields as compile errors instead of silent positional swaps the agent would have to detect from context. The type-checker visibility of every parameter rises; the agent's per-edit completeness-check cost contracts to one named type.
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.
Synthesizing parameter objects that don't represent real domain concepts forces the agent through extra wrapping and unwrapping with no comprehension payoff — pure ceremony. The agent pays the verification-surface cost of an additional type on every call, while gaining nothing in the structural signal the parameter object was supposed to provide.