Hi everyone,
Not that I’m counting down the days or anything, but one week from today (a little longer from when I’m actually writing this) I’ll be moving in to a new flat, so I’m going to tell you about the thing I am second most looking forward to about doing so (the thing I’m most looking forward to is having my own fridge and freezer): Everything that goes wrong in the flat will be my fault (or, at worst, the landlord’s fault).
This isn’t a dig at my current flatmates (not much anyway). I’m far from the perfect flatmate myself, and a fair share of problems in the current flat are definitely my fault too. When I say that every problem in the new flat will be my fault, I definitely don’t mean to suggest that there aren’t going to be a lot of problems. But the fact that all of those problems are mine has a virtue all of its own.
Why? Well, mainly:
Problems that are my fault are much easier for me to fix.
If all the problems are mine, it’s much more worth my fixing them.
If all the problems are mine, I have no plausible deniability about whose responsibility it is to fix them.
Working with other peoples’ problems
Although this is on my mind for flat reasons, this is a pattern I noticed first at work. This, conveniently, gives me a way to avoid making this entire newsletter a litany of complaints about my current flatmates (who are, honestly, lovely people - I’m just in that phase of a change where all the irritations you’ve been suppressing come to the surface).
A thing I saw over and over again at work is that problems that are caused by coworkers or, worse, people outside your company, are vastly harder to solve than your own problems, because they are part of patterns that you have no direct control over.
Consider shipping bugs as a part of a software project. If you introduce a bug, you have a lot of knowledge about how to fix it. If a coworker introduces a bug, you have less knowledge but (assuming you’re part of the same team / product area) you’re probably still familiar enough that you can fix it. It’s harder but it’s not a lot harder.
But that’s not actually the interesting sort of problem at this level. The difficulty difference is relatively bounded. The interesting class of problem is patterns of creating bugs - what happens if someone keeps shipping buggy software?
If that someone is you, this is just a learning and resource prioritisation problem. How bug free do you want the software to be, how much are you willing to invest in it? Can you get better at the requisite skills? Apply the fully general system to the problem and see where it gets you, and you can mostly just solve the problem. It might be hard work, but it’s something you can just apply work to and get the desired outcome, or decide that the desired outcome is not worth the work.
But suppose it’s your coworker who is causing the problem. There is no way you can treat this as something you can just do the work on, because it’s now a social problem. Your options are roughly:
Persuade them to fix the problem themselves, possibly teaching them how.
Clean up after them, creating a constant drain on your own energy.
Get them fired.
Leave.
Ignore the problem.
All of these are some mix of hard, socially awkward, and scary, and they will often burn important social capital or require a great deal of politicking.
(I’ve tried all of them and while (1) is obviously the best option if you can pull it off, (3) and (4) are great options that I can heartily recommend. Avoid (2) at all costs - you will be punished for it because you are now “unproductive” and you will grow to hate the person whose work you are constantly fixing)
(1) becomes particularly problematic when it’s more than one person, because you quickly start becoming a nag - this is worth avoiding because it’s a huge social cost, and also because having to constantly be the only one who cares will burn you out really rapidly (cf. Burnout as Acedia).
This gets worse the larger your social distance (in the non-COVID sense) from the source of the problem is. Inexperienced software developers often want to blame their problems on their tools - the compiler, the standard library, some third party library, etc. They’re usually wrong of course (the more people use a thing, the less likely it is there are obvious bugs in it), but the thing they often miss is that if they were right it would usually be awful. You have very little leverage over the behaviour of third parties, and even small one off issues are now in this realm of social problems where you have to persuade them that it’s actually an issue worth solving.
It also gets worse with less clear cut issues. With bugs at least almost everyone agrees that bugs are a problem (though I’ve had at least one argument with a coworker who was arguing “No they’re not, because we then get paid by the hour to fix them”. I implemented option (4) shortly after that conversation, mostly coincidentally). With many other issues it’s not even clear whether they’re a problem, or which of various solutions to it. For example, shipping features and fixing bugs are both important, but different people will have different trade offs. When you find yourself in these situations, it’s not just a case of whether people disagree with you around whether what you want is worth the effort, now they disagree with you about whether it’s a good idea at all. You’re now no longer trying to persuade someone neutral, you’re being actively opposed.
Diminishing returns
Suppose you are working on a project with five people and four out of five people are pretty much always going to be shipping sloppy code. Suppose further your code is flawless - you’re really investing a lot of effort into making sure it’s as close to bug free as possible - but you’re following my advice that trying to clean up after other people’s mess is a losing game.
Suppose, further, one day you decide you can’t be arsed any more and regress to the standards of everyone else. What happens?
Well, the code gets about 25% buggier. It’s not no impact, but it’s just an incremental change. People might notice, but if the code was already pretty buggy they’ll probably just take it in stride. Conversely, suppose I started sloppy and decided to improve my ways, the best I can hope for is a 20% reduction in the number of bugs.
How does this affect my behaviour? Well, it necessarily changes the trade offs, because the amount of work I am willing to do for something significantly changes depending on how effective it is, and how effective it is is going to be partly measured as a ratio rather than an absolute number of bugs. If I introduce one bug into a pristine software project, I’ll try to correct what lead to that. If I introduce one bug into a product with thousands of bugs, eh no big deal who is even going to notice?
As a practical matter, I think often the effect isn’t actually diminished that much - the impact of each bug in developer time (if it gets fixed) and user time (for however long it takes until it gets fixed) is still the same. The impact is, in reality, still linear even if it feels like it’s the overall ratio, but it’s very hard to intuitively believe that.
For other things though the effect is diminished more than you’d expect. My friend Jonathan suggested the Galahad Principle as the general concept that for some things there is a sharp qualitative change that happens when something is set to 100%, because it turns into something you can rely upon (consider e.g. the qualitative difference between being able to rely on electricity supply and having an erratic one).
Anything that is like this, you can only really maintain as long as everyone is on board with it or you have people clearing up all of the failures. In cases like this, there’s basically no way to achieve the desired goal without changing your coworkers’ behaviour or engaging in significantly more work yourself.
Eric Schwitzgebel talks about how people end up aiming for moral mediocrity - trying to be about as good as or as bad as everyone else around us - and I think this is part of that. Whenever we’re much better than the people around us, the effect of our methods are significantly muted, so the number of morally excellent things it feels worth doing is significantly diminished, so your behaviour will tend to decline.
Kidding yourself about whose fault it is
I’m going to return to the flatmate example in this section because all of my good examples are from that and also because I’m mostly going to be complaining about my own behaviour.
Another difficulty is that it’s very easy to pretend that a problem is caused by someone else when there are someone else’s around to blame. This is particularly true when you’re genuinely not the worst but are still sub-par.
To briefly return to the problem of living together - I am neither the best nor the worst in the flat at doing washing up (I’d say that I’m second best but that there’s a huge step change in degree of conscientiousness between me and the best). There have definitely been times when I’ve gone “Ugh, why haven’t people done their washing up?” only to realise that more than 50% of the washing up in need of doing was mine. When the problem is aggregated across multiple people, it’s very easy to not notice (or be in denial) how much of it is caused by you.
This also shows up in problems that need to be done on a recurring basis. e.g. the bins need taking out. I suspect everyone lets it be someone else’s problem because we all feel like they do it a disproportionate amount of the time.
Caveats
Going it alone gives you authority over all the problems, makes problems responsive to your putting effort into them, and gives you accurate knowledge about problems and your role in them. What’s not to like?
Well in the concrete case, one thing that’s not to like of course is that living on my own is very expensive. As I talked about in Being, Acting, and Feeling Responsible, it’s an expense I feel is worth it, but it’s still a significant expense.
I think this is a general pattern: Individualistic solutions are always more expensive, because they don’t allow for sharing of resources.
As well as increasing the costs, you of course also lose a lot of the benefits. There are some things that you just can’t achieve on your own. Most company’s cannot be run with only a single person’s skills, you cannot form a community of one, etc.
In these circumstances if you want good results you more or less have to figure out how to solve distributed problems, so going it alone and taking ownership of all of your problems isn’t really an option.
(Of course, often people don’t figure that out, and then their community / company / flat etc falls into a dysfunctional mess)
This can crop up even when you’d succeeded at going it alone - just because a problem is your fault, doesn’t mean that it’s within your capabilities to fix, and sometimes you’re going to need to bring in outside help. Usually that’s a temporary affair unless things have gone really pear shaped, but you still end up suffering from these issues a bit.
Despite my complaining, there are things that I’m going to miss about living with other people, and I’m certainly planning on working with others again, so there’s plenty of reason to figure out how to solve this problem rather than just avoiding it by going off and doing my own thing.
But, uh, I’m not entirely sure how to do that. The best I’ve got is something along the lines of sorting out the communication and democratic infrastructure of these groups before it becomes necessary. You need to talk about problems independently from solving them (cf. You should complain about it), and you need to all start with a willingness in principle to try to adjust your behaviour to accommodate others’ needs (which is not the same as feeling obliged to adjust your behaviour to accommodate every need).
It’s also probably important to select for compatibility. You probably shouldn’t live with someone who has vastly different ideas about cleanliness, and you probably shouldn’t work at companies whose goals are poorly aligned with your own (“culture fit” tests get a bad rep, legitimately so, but there’s still some legitimacy to the concept and it’s much less problematic when the individuals are the ones making the decision).
In general I think it’s much easier to fix this early on in the process. Certainly if and when I live with people again we’ll be having conversations about this, and a number of other issues, before we commit to living together.
It’s probably possible to fix it later on, but changing an established culture is often very hard, and you have to be very invested in the group for it to be worth it. If you’re not, it might just be better to give up and take some lessons with you for next time.
On plausible deniability...
This is exacerbated because people care about different things, and underestimate the work happening in areas they care less about.
e.g. you can have flatmates each (accurately) thinking 'I _always_ do the dishes', and 'I _always_ wash the floor', and thus each (wrongly) thinking they do more of the overall work.