Requests to Refuse

A measurement capability attracts requests. Some of them will destroy it, and the answer is easier if it was decided in advance.

A per-developer dashboard

The request: commits, lines, pull requests, build counts per person.

Why to refuse: it measures the system rather than the person, it is trivially gamed, it punishes review and mentoring, and it degrades the telemetry the whole programme depends on.

Offer instead: the team-level system view, and a conversation about the underlying concern, which is usually about one person and is a management question.

A ranking of teams

The request: a league table of delivery metrics.

Why to refuse: context differs enough that the ranking measures the context. It produces defensive reporting and gamed definitions.

Offer instead: each team against its own trend, and a comparison of practices — "that repository has selection configured" — which is actionable.

A productivity percentage

The request: a figure for how much faster the organisation now is.

Why to refuse: it is unfalsifiable, and one challenged number discredits everything else.

Offer instead: specific measures before and after, with the method stated.

Gating on coverage

The request: a merge blocked below a coverage threshold.

Why to refuse: it produces tests without assertions, punishes deleting dead code, and requires instrumentation on the loop where speed matters most.

Offer instead: coverage reported on the change, as a review input rather than a gate.

Using build data in a performance review

The request: telemetry as evidence about an individual.

Why to refuse: it is a purpose the data was not collected for, it will be discovered, and the telemetry will be disabled within a quarter.

Offer instead: nothing. This is the one to decline flatly, and the decision should be recorded so the next request has a precedent.

Removing tests to make the suite faster

The request: delete slow tests.

Why to refuse as stated: it trades a measurable cost for an unmeasurable risk.

Offer instead: find why they are slow, which is almost always setup, and move genuinely slow-but-valuable checks off the blocking path rather than deleting them.

Retrying failures automatically and silently

The request: make the pipeline less annoying by retrying.

Why to refuse as stated: it converts a visible reliability problem into a hidden one and removes the data that would fix it.

Offer instead: retry with the retry recorded and reported, so the flake rate stays visible.

How to refuse

Give the reason, not the policy.

Answer the underlying question with what you do have, which is usually possible.

Write the position down before you are asked, because the first refusal becomes the precedent and deciding it under pressure gets it wrong.

Escalate rather than comply quietly, if pressed. A capability that quietly crosses this line loses the cooperation it runs on, and that is not recoverable within the tenure of the people involved.

Recording the refusal

The first refusal becomes the precedent, which makes writing it down worth the ten minutes.

What was asked, by whom, when.

What was declined and why.

What was offered instead.

Who decided.

Kept somewhere findable, so the second identical request is answered by reference rather than relitigated.

Reviewed annually, because circumstances change and a refusal that was right three years ago may not be — which is a different thing from being overturned under pressure.

Escalating rather than complying quietly

The situation that decides whether the capability survives.

A request that crosses the line, from someone with authority.

Quiet compliance loses the cooperation the programme runs on, and that is not recoverable within the tenure of the people involved.

State the reason, offer the alternative, and escalate if pressed.

Put the position in writing beforehand, so the conversation is about a documented policy rather than about one person's judgement under pressure.

If it is overruled, say so publicly to the people affected, which is the honest thing and preserves what trust remains.