How debt actually arrives

Free preview 5 min to read

Technical debt is usually described as gradual: a slow accumulation, a slope. In this repository it is measurable, and it is not a slope.

The archaeology

The lint job in CI runs bin/rubocop -f github. Here is when it broke, and when it got fixed.

One commit before df07c45:

$ git checkout df07c45~1 && bin/rubocop
401 files inspected, no offenses detected

At df07c45: "Challenges: progressive hints, gated solutions with XP forfeit, friendly test feedback":

$ git checkout df07c45 && bin/rubocop
414 files inspected, 16 offenses detected, 8 offenses autocorrectable

The day before it was fixed, six days and 361 commits later:

$ git checkout df99fec~1 && bin/rubocop
422 files inspected, 23 offenses detected, 12 offenses autocorrectable

Today:

$ bin/rubocop
601 files inspected, no offenses detected

Green, then sixteen, then twenty-three, then green again: fixed in commit df99fec, six days after it broke.

flowchart TB
  A["df07c45~1: 401 files, 0 offenses"] --> B["df07c45: 414 files, 16 offenses"]
  B --> C["361 commits later: 422 files, 23 offenses"]
  C --> D["df99fec, day 6: back to 0 offenses"]
  A --> E["the build was a working signal"]
  B --> F["one commit, one day, one feature"]
  C --> G["seven more offenses across 361 commits"]
  D --> H["one command, one commit, fixed"]

The two halves

The step. df07c45 is a large feature: twenty-plus files, two migrations, two Stimulus controllers, a policy object, locale keys in both languages, a schema change. Sixteen offenses arrived with it, all of one cop, all safe-autocorrectable. Nobody chose this; a big feature landed and the formatter's opinion about array brackets came along with it.

The drift. Seven more offenses over 361 commits and six days. Not a flood: a trickle, in the pattern you would expect from a signal that stopped working.

The second half only happened because of the first. While the job was green, a single offense would have turned it red and been fixed in the same pull request. After it went red, the twenty-third offense cost nothing to add, because the build was already failing.

What this shows about accumulation

Debt arrives in steps, and compounds in slopes. The step is usually a real feature shipped under real pressure. The slope is what happens afterward, and its rate is set by whether anything is still watching.

That distinction changes what a leader does about it, because the two halves have different answers.

You cannot prevent the step. A twenty-file feature will always bring something with it, and a process designed to stop that stops the feature too.

You can absolutely prevent the slope, and it costs one command in the same week. bin/rubocop -a at any point in those 361 commits would have taken under a minute and ended the accumulation. In this repository, it eventually did. Six days after the step, someone ran it, in a commit made within seconds of the two that fixed the search-query and URL-validation Brakeman warnings from a different course entirely.

The number that matters

Not 23, and not the day it was fixed. 361.

Three hundred and sixty-one commits were merged with a failing CI job before anyone acted on it. Every one of them had a red check on the pull request. And every one of them merged anyway, which means that by commit five or ten, the red check had become part of the scenery.

That is the real debt, and it is the part the fix does not undo. The offenses were a minute of work, eventually. The habit of merging past a red check is a property of the team, it took six days to form. And it will apply to the next red check regardless of what caused it, which is the only reason this is worth studying after the fact rather than filing as resolved.

The leader's version of this

An individual contributor reads that story as "we fixed rubocop." A leader reads it as three questions:

How long was it broken before anyone said so? Six days, 361 commits, and it was found (and fixed) by the same pass that happened to be looking at the build for an unrelated reason, not by a process built to catch it.

What else does this pattern apply to? The same week, the same mechanism explained six Brakeman warnings that had also gone unwatched: different signal, same habit.

What made merging past a red check normal, and would it happen again? That is the only question with a durable answer, and it is not answered by the fact that this particular instance got fixed.

Key takeaways

  • Measured: 0 offenses before df07c45, 16 at it, 23 the day before the fix, 361 commits later: then 0 again, fixed in one commit.
  • Debt arrives in steps (a large feature under pressure) and compounds in slopes.
  • The slope only happened because the step killed the signal that would have caught it.
  • The number that matters is 361: commits merged past a red check, until red was scenery, before anyone acted.
  • Fixing the offenses took a minute; the habit of merging past red took six days to form. And outliving the fix is the reason it is worth studying.
Lesson 1 of 7 · free

Keep going with lesson 2

Debt as a portfolio

Five debt categories decay at different rates and need different funding, so manage them by category, not severity.

A free account also gives you the quizzes, your progress and notes, and the discussion.

Type to start searching...