I hit a realization this weekend that I’ve hit many times before. There’s an inordinate number of times when I’m in the office late not because of my own time management failures but because of the people I work with.

Common coworker induced workplace failures:

• Checking in code that doesn’t work at all
• Checking in code that introduces subtle bugs somewhere else in existing code
• Trivial interruptions when I’m in a state of flow
• Playing vacation snafu where they schedule a trip immediately after a deliverable
• Playing priority snafu when a manager or team leader side swipes you with fixing someone else’s problems that really aren’t that urgent compared to what you’re already working on
• Telling me something I’m responsible for is broken, when it’s really because of an error with the way they’re using it
• Letting someone convince me of their interpretation of a spec because they are more experienced and more confident in their opinion
• Following their implementation recipe (that doesn’t work — particularly from managers who aren’t in the trenches anymore)
• Assuming their code does what the comments describes
• Assuming that because a manager asked me for it directly it falls into the 20% of what’s important, not in the 80% of what can be ignored

One of the best lessons you can learn in life is that you can’t change anyone else, you can only change yourself. The minute you put the blame on someone else you’ve switch things from being a problem you can control to a problem outside of your control. Up until this point I’ve put the blame at their feet, but it’s really my fault because of how I interact with them. It all comes down to a case of trust, and with coworkers trust should be earned, not given (at least when it comes to their assumptions). Here are some things I can do differently to avoid those situations.

• Always keep my manager informed of my current priorities and to-do list
• Put on the headphones when I’m in flow and turn off phone/email
• Never, ever check out coworker code when I’m in the middle of debugging my own code
• Always check out a stable version of other coworker code that’s been show to be sane so I don’t spend my time fixing their problems
• Read code, use comments as annotations
• Always create interface assertions when integrating with other people’s code to easily flag when they’re not behaving the way they’re supposed to be
• Regressable unit tests for my own code so that I’m confident that the problem isn’t on my end, and I’m confident I can introduce changes in my own code without have side effects
• Don’t believe a bug exists without seeing it reproduced and seeing the error message
• Don’t believe my interpretation of spec is wrong without digging into it for myself
• Always be mindful, never follow instructions without thinking it through for myself

How have your coworkers unintentionally made your life hell lately?

(To make it clear — put your trust and faith into your coworkers, because your relationships with them will get you farther in life than putting your trust into your company ever will. But there’s a difference between trusting them and blindly trusting their assumptions.)