How can you improve your software testing and debugging?

Moving to a test first strategy to improve quality, and writing minimalist code. Yes, test first strategy is difficult to master and get everyone agree, understand and practice. Extreme programming can be applied where required, while agile ways of working can encourage the test first practice generally for all project types.

This should be obvious, but I think it's important to call out: write down your test strategy in a test plan. Why is that important? Because it gives everyone an opportunity to reference the plan, analyze the plan, and provide thoughtful feedback. Also, testing will never be exhaustive. There are tradeoffs that need to be made because resources are limited. To have an effective test plan, focus on areas that have the most risk. Prioritize those concerns and make sure that there are enough checks in place to build everyone's confidence.

Behaviour driven development is one of the way to automatically create functional tests for the code and can reduce the gap between development, business and operations by collaboration and automation

Actually I disagree with code comments. Comments, like external documentation, can go stale. Speaking from experience, comments can be misleading. Comments and code don't always match. Code should be self-documenting, human readable. Good naming conventions for methods, functions, and variables. Use a linter to catch pro-forma issues: style, smells, etc. Use code reviews to catch semantic issues. As others have commented, TDD or BDD help with the first layer of defense: unit testing. If you've never used them before, it'll slow you down at first. But it'll pay off when inevitable refactors come along.

Yes, but there are also tradeoffs. Automated testing requires maintenance. Now, there's a need to maintain automated test cases and test systems. If there's a major refactor, a ton of automated tests could become useless. False positives and false negatives abound. Automated tests are also inflexible when compared to manual exploratory testing. Unless a code base really sticks to OCP, I can see a lot of extra work to maintain automation systems - fine for companies with lots of resources. I'd go for more unit tests before automated testing frameworks. Unit tests can be maintained as part of development work.

One thing I've found useful is planning for issues in advance. Bugs are normal in software systems. Think about data for debugging early. Having multiple layers of defense against them is essential. Unit tests, code reviews, smoke tests, exploratory testing, and UAT are all layers of defense against bugs in production. Once a bug is in production, the cost to squash it is huge. 10x-100x. Debugging starts with requirements gathering and analysis. The earlier you catch bugs, the less trouble you'll face in the future. Requirements often have bugs and they travel through code into production. Don't rush the requirements part to get coding faster. That's a rookie mistake. An ounce of prevention...

Retrospectives. Retro after a release. Retro after a bug squash. Retro after a refactor. Retro, retro, retro. The only way to really learn from mistakes is to do something like a retro where data about the work process can be presented and analyzed. The best retros have data prepared before the event. Open and honest communication during the event (make a teaming agreement). And a summary of the results and next steps after the event. In the next iteration, take action immediately. Make course corrections as soon as possible to avoid repeating the same mistakes.