How can you debug code that won't compile in Game Development?

Aside from reading the compilation error carefully, try to isolate the system or line of code that is causing the compilation error and start dissecting what you think is happening vs what is actually happening. Work backwards from where you think the root of the problem is up until you are able to find where what you are assuming differs from what is actually happening.

Always read the error message carefully. Many messages are similar, which makes it easy to make a mistake in the investigation process. Be familiar with error codes, double check your compiler settings and warning/error policies. We had cases in the company where code was compiling on PC but not on the consoles. It was because of different default compiler used. Sometimes you may be simply unaware of this!

To this, I will add that it's important to understand in which context the error happens. Mostly, by just understanding where the error came from, at which time, who called the method/function where it's happening, what argument values it could have been called with, is enough to get a better idea of why it's happening. Some other times, more debugging is needed.

Read the error message and seek to understand what caused the error. As you isolate the problem, pay special attention to each step leading to the error. Make good use of debugging tools. Check the basic causes for errors like typos and misused variables. It is easy to overlook the most simple things and sometimes you simply become blind to the code, so take a break. During the break you can explain the error to a colleague and sometimes that alone will be enough for you to come into realization what was wrong.

Using a Debugger is a critical skill of an experienced developer. Not using a Debugger is usually a waste of time. Debugging games can come with challenges associated with running on attached devices. This requires remote debugging skills. Understanding what's a tool chain and how is the tool chain used to build cross platform software and how is the software deployed is very important.

I'd recommend using clang-tidy for C++ projects. The integrations in JetBrains CLion or Rider are great. Valgrind is another established tool that can help you identify problems, especially memory leaks.

This is great to see what changed from your current bugged version from a previous version where the current error isn't present. This is also why you should try to document your commits/check-ins as much as you can, and make as many short clear changes/commits as you can so you, your team and your manager can clearly identify what's going on, what changed, when, why, and understand why a certain feature isn't working anymore. I would also advice to avoid reverting changes lightly, or even make any changes to try and see if the issue gets magically fixed: The key to fixing a bug is to understand the bug. 70-80% of the time we spend bugfixing is the time we spend understanding what's happening, the rest is the (mostly) very simple solution.

Every file in a project is like a story. Some stories are short, some are long and some have many authors and changes. It is sometimes very important to understand the latest changes and history to be able to make contributions that will make it smoothly through a code review.

There are many testing frameworks out there. Different types of testing are useful for different scenarios. My experience tells me that games just don't have any automated test coverage. I think game developers mostly ignore or are not familiar with most software industry best practices.

Try to introduce small coding blocks at the time and test them, it's easier to track any errors. Avoid writing the whole feature and test it once you finished. If you cannot make sense of the compiling errors, try commenting out suspicious code to isolate the offensive part. Looking for examples in your existing codebase, someone else might already be doing something similar to what are you trying to do.