Discover more from Software Design: Tidy First?
Accountability is Not Blame
accountable, adjective, “required to render account”
Tidy First? starts with, “Software design is an exercise in human relationships.” Since human relationships don’t come naturally to me, I’ve been digging into how relationships work before starting on the second book in series. So far we have:
Relationships often need to work across power differentials.
Even in a power-differentiated relationship, both parties choose between cooperative & extractive approaches.
Time & tradition have yielded strategies that encourage cooperation—responsibility (consequences flow towards power), transparency, “commander eats last”.
Some powerful folks, understandably but (in my view) short-sightedly, attempt an extractive approach while keep the less powerful cooperating.
And so we get nonsense like CEOs saying, “I take full responsibility for these layoffs,” while experiencing only positive consequences. That word “responsibility” is supposed to signal the safety of continued cooperation, but has been co-opted.
We have strategies for encouraging cooperation. Counterfeiting these strategies is also valuable. That’s why I differentiate between the strategies (like consequences flowing towards power) & the words we use. Even with the best of intentions whatever word you use to refer to a strategy, someone will come along & twist it.
Here’s another of those cooperation-encouraging strategies: providing an unvarnished accounting of the consumption of resources. If you give me $100 to buy party supplies & I come back with an empty bag & vague explanations, you’re not going to give me $100 again. You will have to buy your own party supplies & our relationship will be damaged.
If instead I say, “I spent $15 on chips & $35 on soda & $55 on hot dogs”, then you will trust me next time. If I also say, “…& $5 on a chocolate bar which I ate on the way home,” well, you might not be happy about the five bucks but you’re going to trust me even more.
I have rendered an account to you of my stewardship of the resources you have entrusted to me. By rendering that account without deflection or blame, I have demonstrated trustworthiness. Our relationship is stronger, more valuable.
“Hold Accountable” is Blame
Blame is the opposite of responsibility—someone with power pushing consequences away from themselves & onto someone with less power. Blame is one of those “power extracts but tries to keep the less powerful cooperating” strategies. Everybody knows the word “blame”, though, & knows it’s bad. So powerful people can’t say “blame”. But (those short-sighted ones) still want to blame. What to do?
Hijack one of those words attached to a constructive concept! Instead of saying, “If this goes badly I’m going to blame you,” the powerful person says, “I’m going to hold you accountable.” (Somehow “holding accountable” only applies if things go badly.)
Accountability in the sense I described it above is a relationship building strategy. “Holding accountable” is blame by another name, a relationship decaying strategy.
Accountability is Vulnerable
The first time I was deliberately accountable I panicked. I was used to deflecting, blaming, manipulating. It felt terrible to just say, “I spent this, I spent that, I wasted this much.”
What I discovered is the only person I was fooling with my deflecting, blaming, & manipulating was me. I felt better, protected, but the people around me felt suspicious. They knew they couldn’t trust me.
When I began to practice accountability people relaxed around me. They were more vulnerable & open themselves. We cooperated more fully.
(Then a person I was accountable to began to use my vulnerability against me, but that’s a story for another day.)
(Power is Subtle)
Something I noticed as I was writing this is that the power in power-differentiated relationships isn’t as simple as “A has more power & B has less & that’s that”. That model is too simple. Power flows along many dimensions & those dimensions change in time.
Take an example from software development. If Manager asks for a new button & Programmer agrees to implement it, it looks like Manager has more power than Programmer. However, Manager has promised the button to Customer. They are on the hook (responsible) for the button without being to actually make it. The power in the relationship has temporarily flowed to Programmer.
That’s why Programmer may want to be accountable to Manager, to encourage trust. If Manager defects, says to Customer, “Well, I wanted to give you the button but you know those dang programmers. Look at all the time they wasted.” then Programmer would be self-defeating to keep being accountable. If Manager continues cooperating even in the face of disappointment, accountability can be the basis for learning & future cooperation.
Accountability also works as a strategy for the relatively empowered person in a relationship. Imagine that CEO saying, “A year ago I saw this information & made that decision. Six months ago I saw this information & made that decision. Now this is the information & I’m choosing to lay people off.” I’d trust that explanation (& that person) far more than folks spouting off about changing macro conditions.