My one major criticism of this advice is that it significantly downplays the importance of communicating clearly among technical people. It's tempting to think

My one major criticism of this advice is that it significantly downplays the importance of communicating clearly among technical people. It's tempting to think this is "easy" but I've seen countless examples among top developers at all sorts of prestigious corporations proving that it's anything but. Some common mistakes I see people make: Excess aggression, ego, and emotion. Check your ego, disconnect your self from instances of your work whether it's your code, your proposals, or your ideas. And be kind to others in criticisms, don't criticize (and especially not denigrate) other people criticize their code or their actions. Instead of saying "this is bad, why would you write this garbage?" say "here's a way to do it that I think is better for X/Y/Z reasons". The work is just the work, it's a collaborative effort to improve it. There should never be shouting or hurt emotions when hashing out designs or doing code reviews, work towards that goal. Insufficient context. Make a habit of regularly summing up context in ongoing discussions and injecting it into the thread (email, IM, meeting, what-have-you). Do this explicitly when looping in new people to a discussion. The worst thing is to be looped into some long email thread and having to follow through the winding and convoluted discussion just to acquire context that could have been summed up by someone in the know with a few sentences. Even worse is when significant amounts of context are missing from the conversation because they happened in person or in other media or happened in previous discussions. Unspoken assumptions. Much like summing up context stating your assumptions is critical to communicating effectively because it's so easy to assume that your little bubble of understanding is universal but it rarely is. And unspoken assumptions are one of the easiest ways for two people (or orgs) to be party to the same discussion and come out of it with completely different conclusions about what will happen next. And on that note, be clear when you're asking anyone anything, whether it's a question or a deliverable. Address them directly, use a question mark. You'd be shocked how often people fail at this sort of thing, especially in large discussion threads. Don't just leave pseudo-questions dangling, waiting for whoever is responsible to pick it up. Be direct, if you don't know who the responsible party should be, ask, maybe nobody knows and it needs to be determined/negotiated. If you know then make sure. And, of course, be polite. Not going on the evidence. A close cousin to riding on unspoken assumptions, especially problematic in troubleshooting and debugging scenarios. Definitely a common mistake I see all the time in CS graduates (who, ironically, aren't very good scientists). Use the scientific method. Don't just make assumptions and tell stories that are convenient or kinda sorta make sense to you. Don't just "satisfice" by resting on the first semi-plausible answer you land on. Dig in, find the truth. Start with a hypothesis (or several), acquire evidence, figure out if you can for sure confirm or falsify your hypothesis (and competing ones) through the evidence. Keep coming up with other things to check that could provide additional evidence one way or the other, and competing hypotheses as well. Keep going until you have a rock solid "case" and can prove your theory. I have seen even very experienced developers screw this up countless times. They come up with some vaguely plausible cause for a problem and then spend way too much time operating as though it's true, without validating it first. And then they waste a ton of time and effort trying to "fix" the wrong thing. Just as often devs will put in a hacky workaround for a defect which just papers over the underlying problem. Pursue defects to their root cause, file bugs in your tracker to keep track of that information and put fixing it on the radar of the team/org/management so at least they are making a conscious choice if they choose not to fix it.