Programming certifications might help improve the quality of the programmers working on the projects but programming is just a small part of application design.
You would have to consider such things as resource constraints when creating applications. Unless you are with a big organization that can afford the time and effort to do everything right, you end up making compromises to get the application package out the door where it brings in cash to pay the bills. The compromises are necessary because you don't have enough resources to do everything right but you do have enough to do things well enough to work.
Of course, even if you are with an organization that can do things right, you run into the problem of not being able to test ALL the possibilities under ALL of the conditions an application faces in the 'wild', especially in a PC environment. Even with automated testing software, it is highly unlikely that you'll be able to duplicate all the conditions that could crash the application.
At best you might be able to get things to the point that there is a one in a million chance that someone will encounter a bug in a given time period. But if that software is used by several million people, then several people will encounter that bug.
Then you have the factor of having to deal with how your application works when other applications are around. If they were meant to work together, then two or more groups have to coordinate things so that you don't end up interferring with how the other applications function. That coordination effort can be hard to manage and may not be handled as well as it could, especially when trade secrets are involved.
And if the applications are completely independent of each other, you DON'T have any coordination to prevent interferrence. At best you might have all the different groups doing 'safe' programming where everyone does all they can to keep their applications from stomping on the toes of other applications.
To add to the above, you need to have a complete and solid definition of the application even before the first line of code is written. There are times when software 'bugs' can be traced to the end users who didn't quite know what they wanted until the application was delivered. These end users have to experience the application in a production environment before deciding that the application has a 'bug' in it that needs to be fixed. It doesn't matter that the application functions as designed, it still has a 'bug' that needs fixing.
It is an interesting world when it comes to application design and buggy software. But things are getting better on the average. What qualifies as a 'bug' today would have been impossible to create thirty years ago because the technology didn't exist.