Is it appropriate to use reflection to create a list of objects of all subclasses?

In my program, different features are divided into different modules, potentially hundreds of modules, each module is a subclass of an abstract Module class which look something like this

public abstract class Module {

    public final String name;

    public Module(String name){
        this.name = name;
    }

    public abstract void execute();
}

with subclasses that look like this

public class Mod1 extends Module{
    public Mod1() {
        super("Mod1");
    }

    @Override
    public void execute() {
        //Do something
    }
}

and I need to make a list of instances of all modules but doing it like this is kinda tedious since my program might have hundreds of modules and it might be hard to debug(I might miss a few lol)

private static final List<Module> MODULES = new ArrayList<>();

public void init(){
    MODULES.add(new Mod1());
    MODULES.add(new Mod2());
    MODULES.add(new Mod3());
    MODULES.add(new Mod4());
    MODULES.add(new Mod5());
}

so I think using reflection might be the way to go but after a quick google search, I see many people don't like reflection in production code, so I come here to ask if this is an appropriate case to use reflection or is there any reason or design change to avoid using reflection in this particular case

edit: the list will be used stuff like rendering modules in gui or calling execute method of the module from other user interface like command(simply find the module with matching name and execute it)

note: this is not how my code actually look like but a highly simplified version that give a similar idea