My view is: "Major bugs are OK *IF* there's nothing else available *AND* if using the program does not piss me off"
I'm in a such situation right now. One app that I used as a frontend for other programs it's abandoned. The program was bug-ridden before the developer released the last version with the promise to release new versions more often (previously, it was semi abandoned during various months). Then, after a couple of months, the guy disappeared off the face of the Earth. Two years have passed since then, without any person picking up its development (the program is open source), although there's some community around it trying to improve it via resource hacking, and using the expandability built into the program.
But too much time passed, mere "patches" (not code patches) are doing nothing to fix the bugs, and I have so many reservations about the program that I consider it as non-functional right now, so many usability issues it has that IMO a full rewrite is needed. Unfortunately, though there are many other options, no one can match some of the features the program has, so what do I do? Reconsider the functionality I need, lowering my demands to only the basic functions, and choose another option. At least, I won't have to waste hours trying to set up the damn thing whenever a major change in the programs it assists occurrs.
Some other thing it's going on with another program, a frontend as well. The guy developing it simply does not have a roadmap of what functionality he wants to add to the program. He even claimed a couple of times that he's abandoning the project because he's not even using it, it's only natural he does not know what he wants inside it, so he implements functions in what I call "programming bursts": he adds many features out of nowhere and releases the program. What happens then? Major bugs arise, the guy cannot fix them, gets angry, and removes the features altogether.
Well, until recently he maintained a clean programming routine, improving the program without removing nothing. But one day, he decided the program had too much fluff: he started to remove features, encountered some bugs, and decided to remove the functions affected. The result? Now I have a program that forced me to change the way the data it interacts with is stored in the computer, affecting other software that use the same data (pissing me off in the process), and it's dumbed down so much that it's a mere reflection of what it used to be (pissing me off even more). Solution? Bye, bye, dumb frontend, and hello, old friend (another program I used in the past that has many more functionality that its competitor right now)
Fun fact: The program replacing the first frontend is programmed by the same guy as the one being replaced in the second story.
EDIT: Proof reading and some rewriting.