I'd be curious what you folks consider discriminators between good and bad developers.
This is a very interesting question. And it would deserve its own thread.
One statement that must be made first is that you don't always need the best programmers. Software that is developed for short-term use doesn't need to be perfect. (Say used for a few years only, not decades). The fewer people use software, the less important it is, and the less important it is that that software is perfect. If you build something that has been built many times before (e.g. a simple website, or an accounting tools with a GUI), you can use standard tools and standard practices. That stuff is simpler.
The challenge comes when you have to build something that is really new. Or something that has to be really fast. Or something that has to scale to thousands or millions of users (or in my case, billions of users). Where you need to think about the overall architecture, where picking the wrong tools can break a project, where every algorithm you use has to scale.
For me personally, the most important property of software is maintainability. And for me, that means a new person, with a decent amount of experience, has to be able to understand what the system is doing. The architecture has to be not overly complicated. There must be a little bit of documentation of the overall ideas and goals of the code. And all the code has to be commented, good function-names and variable-names. It must be clear that the people who wrote the code were aware that someone was gonna come in after the original coders, and those people would have to maintain the system. That is a hard job. I want the original programmers to acknowledge that their successors will have an evenharder job than they had. I want them to think ahead. And try to helpo their future successors.
I don't care about bugs. When you write code, there will be bugs in them. I don't care if there are few bugs or very few bugs. (Of course you shouldn't write code with a dozens of bugs in every function). Software needs to be tested anyway, and you can then find and fix most bugs.
I don't care about speed of execution. Not at all. I do care about scalability. If your software works with a 1000 thingies, it doesn't matter if it takes 100ms or 200ms to execute. However, if you grow your thingies from 1000 to 1 billion, it would be nice if execution time grows from 200ms to only 10 seconds (O(log n)). Not linearly (O(n)) to 1m * 100ms = 100k seconds. Or god forbid, it has O(n*n) complexity. (If you don't know what O(n) means, or what an algorithm's complexity is, go look it up. It's one of the most important concepts in computer science).
Again, the most important property of software is readability. That's what makes the distinction between average and good programmers, imho.