I think code generation can be useful if exactly one of these holds:

• The resulting code can never be edited by a human.
• The code will never be re-generated.

If the code may be regenerated but is also editable by humans, it immediately becomes a maintenance nightmare. Someone will have changed something in the resulting code, someone else changes something in the generation process, and you have a hard to find bug.

The resulting code can never be edited by a human.

This is perhaps the most useful case. Some examples:

• Compiling to other languages. Actually all kinds of compiling are code generation, in a way. But e.g. compiling to Javascript is obviously useful and popular. It can be harder to debug though.

• Templates, macros, generics. Can be hard because especially the former lack type safety, and error messages may relate to the result instead of the transformation code. But very powerful.

  Languages differ greatly in how they handle this (and whether they even use it at all, or use reflection instead, or nothing). See this question.

• Adding code using @Annotations in Java. Makes the code more implicit, but for commonly known macros that's okay, and can save quite some boilerplace and duplication.
• Generate data object and parser from e.g. an xsd schema. That way one keeps type safety but doesn't repeat the structural information.
• Building SQL queries from application code at runtime. This is useful (perhaps necessary), but I think it should be done in a type-safe way with objects, rather than string concatenation.
• CPP processing derictives. Not a great example.

Ideally I'd want these to happen at compile time, with the resulting code never exposed to the programmer, because it shouldn't be changed.

The code will never be re-generated.

Here you generate code that you then edit and becomes part of the project.

• This can be used to generate the structure and boilerplate of your project, that you then adapt. It can save some effort and help keep the code layout consistent. E.g. many frameworks come with a command to create an empty project.

  Where possible, it's better not to need the boilerplate. But there'll be some, so this has a place.

• Things like live templates and autocomplete in IDEs are very small-scale example that I think is harmless and useful.