Quill.

·  

The cost of a decision you never revisit

Every codebase carries a handful of choices nobody has looked at since the week they were made. They are not bugs, and that is exactly why they survive.

There is a particular kind of technical debt that does not show up in any of the ways we normally look for it. It does not throw errors. It does not appear in the flame graph. No linter flags it and no retro surfaces it, because nothing about it has gone wrong. It is simply a decision, made once, correctly, that nobody has looked at since.

I have started calling these settled decisions, and I think they are the most expensive thing in most codebases over a five-year horizon.

How a decision settles

A settled decision has a particular history. It was made deliberately, usually by someone competent, with reasons that were good at the time. It was written down somewhere — an ADR, a wiki page, a long Slack thread1. And then the context that justified it changed, gradually, without anyone noticing that the decision was now load-bearing on assumptions that had quietly stopped being true.

The classic shape: a service was split out because a team was going to own it. The team was reorganised eight months later. The service is still split out, and now two people who sit next to each other deploy it separately and coordinate over a shared Slack channel that exists solely to manage the seam.

The question is never "was this right?" It is "would we choose this now, knowing what we know?" Almost nobody asks the second one. — something I wish I had said earlier in my career

Why they are hard to see

Three things make settled decisions invisible, and they compound.

The decision was correct

This is the difficult part. If the original choice had been a mistake, someone would have complained within a month and it would have been fixed. Because it was right, everyone who encountered it concluded — correctly — that there was a reason. That conclusion is where the investigation stops.

The cost is diffuse

No single person pays enough of the cost to build a case. Thirty seconds of confusion for every new engineer, an extra deploy step twice a week, one class of bug that recurs every few months. Add it up across four years and it is weeks of time, but it never arrives as a bill anyone can point at.

Nobody owns the review

We have processes for making decisions and almost none for revisiting them. An ADR template has a "status" field, and in my experience it reads Accepted forever. There is no calendar invite for "check whether this is still true".

A cheap intervention

I do not think this needs process. It needs one habit, and it costs about twenty minutes a quarter.

Take your decision log — if you do not have one, that is the actual first step and it is worth its own post. Pick the three oldest entries that are still in force. For each, write two sentences:

  1. What did we assume, that we have not checked since?
  2. If that assumption is now false, what would it cost to undo this?

Most of the time the answer is "still fine" and you have spent seven minutes. Occasionally you find one where the assumption has been dead for two years, and you have just found the cheapest improvement available to you this quarter.

Time since the decision was made accumulated cost visibility
The gap between the two lines is where settled decisions live.

What this is not

It is not an argument for churn. Revisiting a decision usually ends with keeping it, and that is a successful outcome — you now know it is still right, which you did not before. The goal is not to change things. It is to stop the set of unexamined assumptions from growing without bound2.

It is also not a criticism of whoever made the decision. In four years someone will read something you chose last month and wonder why. The honest answer will be "it was right then", and they will be as correct as you were.

Where to start

If you do nothing else: next time you write down a decision, add one line at the bottom.

This holds as long as: the payments team owns reconciliation
and we stay under ~50 merchants.

That single line converts an unexamined assumption into a falsifiable one. Somebody will eventually read it and notice that there are now two hundred merchants, and the whole review happens by itself.

  1. The Slack thread is the worst of the three, because it is searchable in theory and unfindable in practice. ↩
  2. There is a tidy analogy here to unbounded queues, which I resisted making in the body text and have now made anyway. ↩