Software is hard. Really, really hard. You just won't believe how vastly, hugely, mind-bogglingly hard it is. I mean, you may think it's a long way down the road to the chemist -- er, ok, but you know, software is hard.

Unfortunately, part of the reason software is hard is that we, the majority of us, even in software development, do not know how to do it right, or even well. Especially when it comes to the software engineering things that go around the actual core code itself.

Pretty much every software project I have ever worked on or used has been obviously terrible in terms of basic usability, user experience, quality, sanity, cleanliness, etc., pretty much all immediately obvious within the first 10 minutes of using it. (That doesn't mean they are all useless projects. Hopefully far from it. They've paid my bills at least. But that doesn't mean they were great, to me, if they had these other issues. So probably there has never been a great project ever, according to me. Like I said: it is hard.)

And I really do indict myself here, not just everybody else in software. :-) By putting this off-the-cuff list up I hope some folks can think about what tools or processes could be invented or refined in order to nullify them. (On which I have my own thoughts, but you can try doing your own 5 Whys on them.)

• Not having anything better than a somewhat mediocre if not downright bad installation experience (e.g. anything written in C or C++ that I have to try to get to build on my machine).
• Purporting to be 'cross platform' but then instead of actually really solving it or at least admitting where it isn't being solved well, just sort of either rationalizing it or maybe really being unable to even see the suck?
• Not spending enough time to get good quality on The Naming of Things. 
• Not having progress bars or verbose modes or any of the things people need when they are trying to figure out WTF.
• Not doing continuous integration.
• Not having 'sufficient' unit tests.
• Not having somebody dedicated to devops on the project.
• Having a checksum for file downloads, but not saying precisely what kind of checksum it is.
• Not managing versions properly (e.g. ending up with a flood of warnings when people run the build, and then you apparently can't do anything about it until some future release because of some versioning nightmare constraint).
• Using some kind of overly fancy web fu on the documentation, such that it even breaks the freaking back button navigation. Let alone looks and behaves kinda crappy.
• Not presenting a unified one-throat-to-choke front to users who just wanna get their work done, not learn the inner byzantine component architecture of your system.
• Not having great documentation. Like, maybe you have a lot of documentation, but I still can't find the answer to my question, or even know how to find if the answer isn't in the docs.
• Letting documentation drift out of date just to screw the newbies.
• Trying to reinvent something yourself as a component in your system (e.g. event bus) when you could maybe have used something that already exists and has miles on the tires and mindshare and S.O. answers and documentation and etc.
• Trying to use communication mediums that turn up less in web search results, because I guess you want people to ask the same thing ever over instead of just finding the answer via e.g. Google+StackOverflow?
• Not using or passing static checks, for example IntelliJ's"inspections".
• (Using any tool that itself kinda sucks. At least try to pick the one that sucks least. (That is, of course, impossible.))
• (Personal bent: using a language that isn't amenable to static type checking.)