The alternative to self-similarity at different scales has already been tested and more or less rejected: it's DSLs of the kind Lisp and Smalltalk let you create. The idea being that you build a high level language out of abstractions and it levers up the language.
The problem is that a custom language so built is harder for newcomers to the project to get to grips with. If it's a super common problem, and the solution gets popular, it might work out - see e.g. Rails with its DSLs for migrations, routes, etc. But that's a small fraction of problems. Hired developers don't really want to learn you custom thing, too, as it reduces their market value.
How was that idea rejected? Building languages out of abstractions is almost all of what you do when programming. When you create a bunch of functions and group them in a module, you've created a piece of language. An abstraction layer is a language that things above are coded in.
Lisp/Smalltalk DSLs only expand your capabilities here to syntactic abstraction / code generation. But the overall principle is the same.
The problem is that a custom language so built is harder for newcomers to the project to get to grips with. If it's a super common problem, and the solution gets popular, it might work out - see e.g. Rails with its DSLs for migrations, routes, etc. But that's a small fraction of problems. Hired developers don't really want to learn you custom thing, too, as it reduces their market value.