You can't debug a verdict

If you’re the kind of person who fixes things for a living, engineer, founder, doctor, analyst, you’ve probably tried to fix your marriage the same way you fix everything else: find the root cause, design a solution, ship it, iterate. And you’ve probably noticed it isn’t working, and might even be making things worse. That’s not because you’re bad at debugging. It’s because the recurring fight isn’t a bug. It’s a conviction, a settled judgment each of you holds about the other, and convictions don’t respond to debugging. You don’t patch them. You drop them, which is a completely different operation.

Why doesn’t the engineering approach work on this?

Because debugging assumes the thing you’re fixing has no opinion about being fixed, and your marriage does. When you root-cause a slow database, the database isn’t insulted; it doesn’t get defensive; it doesn’t experience your investigation as an attack and retaliate. Your partner does all three. So the tools that work beautifully on indifferent systems backfire on a person. You run a calm post-mortem on last night’s fight, and your partner doesn’t experience a neutral analysis, they experience being put under a microscope by someone who’s already decided they’re the defect. The precision that makes you great at your job becomes, aimed at a person, one more way of saying “you’re the problem, and I’m going to prove it methodically.” The method itself becomes part of the fight.

But we did find the root cause. Why does it keep happening?

Because you stopped one level too high, at the pattern, when the thing driving it sits one level below that, at the judgment. You correctly identified the mechanics: she raises her voice, he goes quiet, the topic doesn’t matter, it’s the dynamic. Good analysis, all true, and it changed nothing, because underneath the pattern is the layer your debugging can’t reach: a conclusion each of you has reached about the other’s basic character. “He’s cold and doesn’t care.” “She’s chaotic and irrational.” That’s not a process fault you can fix with a better process. It’s a conviction, and a conviction isn’t in the mechanics of the system, it’s in how each of you sees the other, deciding what every data point means before you’ve even finished collecting it. You found the bug in the code. The actual problem is in the compiler that’s reading all the code as guilty.

What’s the difference between a bug and a verdict?

A bug is a mistake in a system that has no stake in staying broken, so you find it, fix it, and it’s gone; it doesn’t argue. A verdict is a judgment a person is actively holding, and it behaves nothing like a bug. It defends itself when challenged. It reinterprets new evidence to keep proving itself right, so every “counterexample” you present gets absorbed as the exception. And it produces the very behavior it claims to have merely observed: treat someone as cold long enough and they withdraw, which the verdict then points to as proof. No debugging process handles an error that argues back, rewrites the incoming data, and manufactures its own supporting logs. That’s not a technical problem. It’s a human one, and it needs a human move.

So what’s the move, if not debugging?

Retracting the verdict, which isn’t a fix you apply to your partner but something you put down in yourself. You can’t debug your way to it, because it was never in the mechanics; it’s in the conviction each of you is holding, and the conviction is protecting something, usually a judgment about yourself you’ve never made peace with. The good news, and it’s the part analytical people tend to like once they see it, is that this is still a real mechanism with a real leverage point; it’s just located one layer deeper than you were looking, in the observer, not the system. The whole thing is laid out in The Unforgiven Self, the sessions are described the way you’d want them on the how it works page, and the page written for couples like yours is here: engineers and high performers.