There Is No Compiler for Leadership

When I was writing code, I always knew when I was wrong. The compiler told me. Tests failed. The app crashed in a way that pointed directly at the line I'd broken. The feedback loop was tight, sometimes annoyingly so, but it was there.

Leadership doesn't work like that.

You make a call, and then you wait. Weeks, sometimes months. By the time the outcome is clear, you've already moved on to the next problem. The team has shifted. The context has changed. And your memory, which you'd like to believe is a reliable narrator, has quietly edited the story.

You'll tell yourself you saw it coming. You didn't always. That's not dishonesty, it's just how memory works. It fills in gaps with whatever makes the most sense in hindsight. Without something to check against, you'll confuse luck with skill and pattern recognition with coincidence. Learning turns into storytelling, and you get worse at the job while feeling like you're getting better.

The Missing Feedback Loop

Engineers have feedback loops built into the work. Code compiles or it doesn't. Tests pass or they fail. Something breaks and a system tells you where. The signal is immediate, specific, and hard to ignore.

Leadership has none of that by default. Decisions are made with incomplete information, under time pressure, with consequences that won't surface for months. When things eventually go wrong, there are usually enough variables in play that it's genuinely hard to know whether the original call was bad, the execution was off, or you just got unlucky. When things go right, it's even harder to know why.

So most leaders do what feels natural: they rely on memory and instinct. They carry their decisions in their heads, develop a general sense of how things tend to go, and call it experience. The problem is that memory is a terrible data source. It's selective, self-serving, and impossible to audit. You can't go back and check what you actually thought at the time, because the outcome has already colored it.

If you want to actually get better at making decisions, you have to manufacture your own feedback loop. And the most straightforward way to do that is also the most unglamorous: write it down.

The Habit

Not a journal. Not a system. Just this: when you make a significant call, write down what you decided, why you decided it, and what you think will happen. Then set a reminder to come back in 60 or 90 days and read it.

That's the whole thing.

When you come back, you're not looking for a grade. You're looking for signal. Did the outcome match what you expected? If not, where did your thinking break down? Were you wrong about the problem, the people, the constraints? Or were you right and just unlucky?

You can't answer those questions if the original thinking is gone. But if you wrote it down, you have something real to work with. Not a memory of what you thought. The actual thing you thought, at the time, before you knew how it turned out.

That's the difference between experience and a feedback loop.

The Close

Leadership without a feedback loop feels like intuition. And sometimes it is. But intuition built on unexamined experience is just pattern matching with no quality control. You reinforce whatever you did before, whether it actually worked or not.

The goal isn't to turn every decision into a documentation exercise. Most calls don't warrant it. But the ones that matter, the ones where you're operating with real uncertainty and real consequences, those deserve more than a mental note you'll rewrite six months later.

Write down what you decided. Write down why. Come back and check.

It won't always be comfortable. That's the point.

The Leadership Decision Log is a simple system for capturing decisions and building your own feedback loop. If the habit sounds right but starting from scratch sounds annoying, it'll save you the setup.