Part of the reason computing is in a sorry state is due to poor interfaces. Rather than retiring an interface, the common reaction to some need is merely to extend it. Worse, this is that reaction to deficiencies of all sorts. This leads to the titular quality which I notice in the world around me. This quality is brought about by addition rather than subtraction, by convention instead of rule, by discarding what little model of the system be present. Worse, it's omnipresent, layers upon layers.
A machine code can be a good example. Without foresight, some flaw will eventually be noticed, some inability to do something which is necessary, and this can sometimes be corrected through blessing a particular sequence of instructions. What happens with this is that the specification has just been extended, in a particularly vague and vile way. Eventually, the model of the processor can become a mess, with errata littered about, and what model could such a processor be said to implement at that point? This is an almost-inevitable result of haphazardly extending an instruction set for decades.
This quality isn't limited to machines. Common operating system software, the both of them, exhibit such degeneration. The models are filled with hacks and exceptions without concern, in that name of portability or security or whatnot, and it makes for an incomprehensible pile of nonsensical values. Providing a common interface and forcing everything to adhere to it is either never done or is never done well at a suitable level to prevent it from bubbling forth. It amuses me to read of flaws that were written decades ago being corrected but recently; rather than ever rewrite, I see the religious cults of the false gods carry their source code for decades as if it were their Ark of the Covenant.
I'm guilty of creating omnipresent mismatch in one of my systems, Meta-CHIP-8. Eventually, I'd made the model invalid, by creating a very special case to avoid that need to further fiddle with it, but I corrected this by later discarding that system and entirely rewriting it, something sorely missing from modern software in which all of the concern is in retaining those millions of lines of garbage.
The WWW is a particularly good example of omnipresent mismatch; lacking any foresight, even spelling checks, the model blundered on for decades, being extended in the most shortsighted of ways. I view little time passing by without some major issue that demands an adjustment of the semantics, largely involving the programming language nailed into its side. The business interest in it is but amusing in light of its disgusting flaws and basic mistakes; it's most commonly used for anything except the few purposes for which it's adequate, and making it more ``capable'' will but hasten its collapsing.
Omnipresent mismatch begets omnipresent mismatch. A proper system may be set on one broken, but not easily, and it will have queer omissions unless it be a convenient subset of the broken layer. What is more easily done is piling on another broken system. A lack of thought is the prime commonality.