This is actually a pretty normal way for software development to work.
Normally, compile and basic runtime bugs are found by the developer while they make the feature.
The tricky bugs happen when all the features are built and have to interact with each other. Therefore it makes perfect sense to wait until the end before fixing bugs.
As for fixing old feature bugs. Sometimes these are ignored if the price to fix them is too high, or if the feature is going to be replaced or removed soon.
Sometimes, the bugs take on a life of their own and become a feature of the software.
As a quick example, I once had a screen that was for a calculation, the final line, the total, was editable because it could be inserted by third party software. Funny thing is, this field wasn't locked to a number, but allowed letters by accident. Eventually a developer saw this and fixed it. A day later customers started complaining they could no longer type comments into the total field. Whoops! Nobody knew they were doing that. They weren't supposed to be doing that. But the users discovered they could, and did. Eventually it became a business requirement for the users to do this.
And sometimes the bug is really deep, and other developers have built code on top of the bug, patching it in other ways. So if you fix the original bug, you break all the code that expected that bug to be in place. This sounds silly but it actually happens a lot.
It might be something like. You as a developer, discover that a core module has a function that adds 2 numbers together, but accidentally adds a 1 to the end all the time.
1 + 1 = 21, 6+6=121. So you contact the developer that wrote the module and ask them to fix it. It goes to the backlog because they are busy working on a feature, no time to fix bugs. But your on a deadline. So you just write your code to chop off the last character of whatever the function returns. Job done.
A month later, that core developer fixes the problem. Now your code is broken.
This is a very simplistic example but I hope it gives the right idea.
So the drawbacks of this system are that bugs will often be deemed too expensive to fix. But the positive side is development speed is drastically increased as developers aren't trying to debug someone's code all the time while working on their own.