Comparing graphical meta-circularity with conventional software toolchains

Computer software, seen as a medium, can behave in any way we want within the
physical constraints of the device it's on. In theory, people are already carrying
around universal simulators that they can tailor to their own desires. In practice,
this is infeasible. Most software appears "fixed" or unchangeable, and must be
accepted as-is.
If a user wants to adapt some spreadsheet for their own context, any ordinary
spreadsheet application will do. But if they are dissatisfied with this application
itself, then to do anything about it they must become familiar with its language,
development, and architecture, before then forking and maintaining their own
version - assuming it's open-source in the first place.
Even if such an immense time investment succeeds, the same problem is simply
pushed one step further. Although their text editor and compiler let them adapt
the spreadsheet program to their wishes, if they wish to adapt these tools, they
must go through the entire process again for each one.
The overarching metaphor is of "making" software "products" or "artefacts",
modifying them with software "tools". Such do not come with their own mechanisms
for adaptation, but rely instead on bringing in separate artefacts. The
text editor, compiler, operating system and language runtime are all themselves
software "products" previously "built" in such a way.
Nevertheless, all of this is software, made using itself. It must be asked whether
the stark boundary between tool and product is really an unavoidable property
of the material itself, or just a consequence of a particular methodology.