Given the above, I propose building a system with the following design objectives:

fast compilers

generated compilers execute quickly, and are simple when the language is simple. Support RTCG.

(semi)automatic

compiler generation, convert interpreters into compilers with minimal human direction. Support lightweight languages.

composeable

to handle highly abstract, modular input. handle both multiple layers of interpreters, and multiple stages of generation.

powerful

so the programmer is not restricted to a toy language. At least polymorphism, data structures, higher-order control flow, exceptions, and side effects must be handled.

predictable

the results and termination of the code transformations are understood by the programmer.

These are contradictory goals. Current techniques do not completely automate compiler generation (and it's hard to imagine how they could). As you approach full automation, predictability goes down as more and sophisticated analyses and inferences are required.

In any cogen where the input and output languages are equal (see layers), there is a trade-off between exposing more operations for static evaluation by making this language lower level, and weakening the partial evaluation (or requiring analysis to reconstruct lost information), and reducing the final quality of code.

These conflicts have a very familiar feel to them; they are typical of any intermediate language design.