I think there's a really important aspect to this that the software industry needs to confront in order to mature. To some extent - not completely, but at leas

I think there's a really important aspect to this that the software industry needs to confront in order to mature. To some extent - not completely, but at least partially, power and unmaintainability are two sides of the same coin. That is, it is exactly the same properties that allow your amazing macro to boil 15 dimensions of a problem down into a single beautiful one line piece of code that also make it an unacceptable liability that should never be allowed into a mature codebase [1]. Because if the macro didn't exhibit that amazing sublte complex behavior then it wouldn't be powerful. But exactly by doing that, it is now something that nobody new can understand. There is also a fraction of the software "power" equation for which it is a win-win: more power equals less overall non-essential complexity in the system and the burden of propagating the associated knowledge is lower than what is saved. However distinguishing the above two things is completely non-trivial and if you can't actually do that well you need to fall back on the side of avoiding overly powerful behaviors if you want to have an actual long term, large scale, maintainable outcome. [1] Obviously this is an overreaching statement. But to a first approximation this is true and the exceptions by definition have to be rare.