The other caller of the code you changed

Shared code has more than one boss

Yesterday's ticket was small. Sessions shorter than a minute were billing zero minutes on the usage report. An assistant was pointed at the report, followed the number back to a shared helper called minutes, and changed the helper to round up. The usage suite went green, the diff was one line, and it shipped.

This morning a different team's pager fires a minute early on every job, because their alerting module calls minutes too, and it was built on the promise that a partial minute does not count. Nobody edited that module. Nobody opened it. It was not in the context window, and it had no test at the boundary where the two answers differ.

That is the most common regression shape in AI-assisted work, and this lesson starts where you actually arrive: after the change landed. Two callers want two different things from one function, and the function currently serves one of them.

Find every caller first

Before you judge any change to shared code, get the list of who depends on it. Search the repository for the function name and for imports of its module, then write one line per call site saying what that caller asks for. It takes a minute, and it is the entire difference between a repair and a second outage.

Written out, the conflict is obvious and the one line change stops looking like a fix. Here is the same shape with storage sizes, so the pipeline trace stays yours to do:

# storage/size.py
def kilobytes(byte_count):
    """Whole kilobytes stored. A partial kilobyte does not count."""
    return byte_count // 1024


# quota/enforce.py
def over_quota(byte_count, limit_kb):
    return kilobytes(byte_count) > limit_kb    # wants whole stored kilobytes


# invoices/lines.py
def storage_charge_kb(byte_count):
    return kilobytes(byte_count)               # wants any started kilobyte charged

The change lives where the need lives

A helper's docstring is a contract, and every caller signed it. When one caller needs something different, the difference belongs in that caller, or behind a new parameter whose default preserves the old behavior for everyone who did not ask for a change.

# before: the invoice's rounding was pushed into the shared helper
def kilobytes(byte_count):
    return (byte_count + 1023) // 1024    # quota now trips one kilobyte early


# after: the invoice rounds up at the invoice
def kilobytes(byte_count):
    """Whole kilobytes stored. A partial kilobyte does not count."""
    return byte_count // 1024


def storage_charge_kb(byte_count):
    return (byte_count + 1023) // 1024

The move to avoid is a branch inside the helper keyed on who is calling. It keeps the code in one place, which feels tidy, but the shared function now knows its callers by name, and the next caller either lands in the wrong branch or adds a third one.

Prove you did not break the neighbor

The reason yesterday's change survived review is that the neighbor had no test at the boundary where the two rules disagree. Whole minutes and rounded up minutes agree on every exact minute and differ on every other input, and the alerting suite only asserted exact ones. So the repair is not finished when both suites pass. It is finished when the drifted boundary has the test the neighbor was missing, which is why the alerting suite in this lesson pins 179 seconds and 59 seconds rather than only 180 and 60.

Pitfalls

• Reverting the helper and stopping there. The neighbor recovers, the caller that asked for the change breaks, and you have traded one outage for the other.
• Branching inside the helper on which caller is asking. One shared function that knows its callers by name is harder to change than two honest ones.
• Copying the helper into your caller and editing the copy. It ends the argument today and starts a drift bug next quarter.
• Reading green CI as a list of callers. It is a list of tests, which is a different and usually shorter list.

Interview nuance: in a pairing round, a shared helper with a second call site is seeded on purpose, and the interviewer is watching for one sentence. Saying "before I touch this, let me see who else calls it" and then actually searching is one of the clearest experience signals you can give, because it shows you have been on the receiving end of somebody else's local fix.