Why I Don't Fix a Problem the First Time

I don't fix a problem the first time it happens, because one occurrence can't tell me whether I'm looking at a pattern or a bad day. I log it the first time, investigate the second time and build the fix only on the third.

Why I Do Not Fix a Problem the First Time It Happens: A Rule from My Operator to Builder Transition

The most useful discipline I picked up in my operator to builder transition is also the one that looks most like negligence from outside. When something breaks for the first time, I don't fix it. I write it down, and I wait.

That makes careful people uncomfortable, and it made me uncomfortable for a long time. So I'll explain what it actually means, why it took me years to learn and how it changed the way I build.

The Old Frame: Every Failure Deserves a Fix

For most of my operating life I treated a failure as a debt to close at once. A report went out wrong, so I added a check. A vendor was paid twice, so I added an approval. A handoff got dropped, so I added a step, and each fix felt like the mature, responsible thing to do.

What I didn't see was how the cost added up. Every fix is a permanent charge on the system, because it adds a step, a rule or a branch of logic that every future person or process has to carry. I was closing single incidents by making the whole machine heavier.

This is founder psychology scaling in the worst direction. The instinct that makes a founder good at firefighting, with fast reactions, total ownership and zero tolerance for a repeat, is the same instinct that clogs the system with special cases. The firm ends up with a process that is 30 steps long because 30 things went wrong once, years ago, and nobody ever went back to remove the extra steps.

The Moment It Clicked

I run my business as a personal operating system, a set of AI agents and rules that handle real work, and I build it in public. That decision forced me to change how I treat failure, because now every failure is logged, timestamped and visible.

A few weeks ago one of my agents produced a wrong output on a routine task. The old me would have stopped everything and written a new rule that night. This time I did what the system is designed to do: I logged the incident and left the rules untouched.

It hasn't happened again, not once in the weeks since. Had I written the guardrail, I'd now be maintaining a rule against something that happened a single time and might never return. That rule would sit in my files for good, read by every future version of the agent and slowing every future decision, with nothing to show for it. That's when the principle became concrete for me: nobody can tell a real signal from noise when they have only one example.

The Rule of Three

This is the framework I use now. It's deliberately boring, and that's the point of it.

FIRST OCCURRENCE. Log it and change nothing structural. Write down what happened, when it happened and what it cost, without adding a fix, a rule or a new step, because at this stage I'm collecting evidence rather than acting on it.

SECOND OCCURRENCE. Investigate. With two occurrences I can start to see a direction, so I check whether it failed the same way or a new way. A repeat of the exact same failure is a signal, while two different failures that happen to look alike are still noise.

THIRD OCCURRENCE. Build the fix. Three of the same failure make a pattern, and a pattern has earned a permanent place in the system. At that point the charge is worth paying, because the fix is paying down a cost that is real and recurring. The rule of three does one job: it stops me designing for events that never come back.

Why This Is the Hard Part of the Operator to Builder Transition

An operator is paid to make the problem in front of them go away right now. On the floor of a live business that's the correct behaviour, and I spent 14 years getting good at it inside large operations. When the line stops, nobody runs a three-occurrence study; they fix the line.

A builder is paid to design the system that decides which problems are worth solving at all. The two jobs have opposite reflexes, because the operator's reflex is to act and the builder's reflex is to watch. For me, the whole transition has been learning when to switch which reflex on.

The tell is discomfort. If sitting with a broken thing feels wrong, I'm probably still wearing the operator hat. Learning to leave a first-time failure alone on purpose was the clearest sign that I'd actually started building instead of just executing faster.

What This Looks Like in Practice

This is the short checklist I run before I build any permanent fix:

  • Count the occurrences. One occurrence tells me nothing yet, two show a possible direction and three make a pattern.
  • Check the shape. This shows whether the same failure is repeating, or whether I'm matching different failures together because of my mood.
  • Weigh the charge. I compare what the fix will cost every future run with what it costs if the failure comes back.
  • Name the trigger. If I won't fix it now, I write down the exact signal that will tell me it's time.

The last one matters most, because waiting and ignoring are different things. Every logged incident carries a condition that would promote it to a fix, so I'm watching to see whether it earns my attention rather than hoping it goes away.

The Principle

Speed of reaction is an operator's virtue, and restraint is a builder's virtue. Moving from one to the other has nothing to do with getting slower; it means spending fixes where they keep paying off and refusing to spend them where they only add weight. A business, like a codebase, is defined as much by what its owner refused to add as by what got built.

A system patched for every one-off turns into a museum of problems that only happened once. I'd rather run a lean machine that occasionally repeats a small failure than a heavy one that has never made the same mistake twice and can barely move. When something breaks in your business, how do you tell a pattern from a bad day before you spend real effort fixing it?

The One Exception

There's one class of failure I do fix on the first occurrence, and it's worth naming so the rule doesn't sound reckless. If a single failure is irreversible or unsafe, waiting stops being discipline and becomes negligence. That covers a payment that can't be clawed back, a loss of data with no backup and anything else where the first occurrence is also the last chance to learn. Those get fixed at once, because the cost of one more instance has no upper limit.

The rule of three is for reversible failures, where a repeat is annoying but survivable, and those make up most of what breaks in a business from day to day. The skill lies in telling the two kinds apart honestly, without using the word irreversible as an excuse to keep firefighting everything.

What a Real Pattern Looked Like

The opposite case teaches just as much. Earlier this year a particular handoff between two of my subsystems failed. I logged it and waited, and a week later it failed again in the same way. I investigated and still held off. The third time, the pattern was identical and impossible to argue with, so I built the fix: a shared record that both systems now read before they act.

That fix has paid for itself many times over, because it solved a pattern rather than a single incident. If I'd built it after the first failure, I would have guessed at the cause and probably designed for the wrong one. The two extra occurrences told me exactly what to build, so the wait saved me from a useless rule and also made the final fix correct.

Pick a time that suits you.

Book a call