Once upon a time I worked at a moderately-sized (a couple hundred people) software company that was essentially run by a group of buddies who were its original founders, all in various technical roles. One of those guys had... very strong opinions about how software should be written. To sum it up, everything is done wrongly, and if it would only be done right - i.e. the way he envisioned - software would be much better.

Now the company, up until then, was writing everything in C++ (this is mid-00s, and they are doing low-level stuff to boot, so it kinda made sense). However they had trouble finding enough qualified C++ devs. This meshed with some of his ideas of using higher-level approach to parts of the product so that "idiots" (his words) could work on it, while "smart guys" could tackle the low-level issues. He managed to sell it to the rest of the group and to their funding sources, and appointed himself "chief architect".

The logical thing at that point would be to take something like say Java or .NET. But, you see, they were also designed "wrong". So, instead, we would write our own thing, that would be even higher-level, but done "right". I believe something like a quarter of the company was eventually involved in this effort, and he insisted on the rest using the bits this team produced basically as soon as something worked (even if things would break all the time), so product development also ground down nearly to a halt.

I was one of the people working on this boondoggle, although I came in at the middle of it, when it was already kinda sorta working... so long as you didn't look at it wrong. The whole thing was pretty much crutches and duck tape from the bottom up. At the bottom layer it was COM-esque framework for C++ that gave you things like garbage collection and reflection. On top of that sat the remoting layer, complete with its own protocol, proxies/stubs etc (COM, CORBA etc were all "wrong"). On top of that we had a bespoke UI framework, with declarative markup written in XML and widgets bound to data models via its own custom high-level interpreted language that was inspired by XPath adapted to object graphs. On top of all this we had a bunch of libraries similar to .NET & Java stdlibs, to do stuff like filesystem access, SQL queries, and so on - some of it wrapping existing C++ libs, but most written from scratch.

The guy insisted that once we had it all polished, productivity and quality of software produced by the company would skyrocket. In practice, the engineers working on all this were overwhelmed by the requirements, and most of us had no experience doing anything like that, so we learned as we went, with some amusing results. For example, codegen for interface definitions (also written in yet another bespoke language, because of course IDL was "wrong") was done by having a parser emit XML which would then be processed by gnarly XSLT (and, later, XQuery) stylesheets. The garbage collector used cycle detection on top of refcounting, but the former was so slow that releasing an object graph of a few thousand objects took on the order of 10s. The UI framework guys were constantly fighting with layout engine. And so on, and so forth. Amazingly, the "chief architect" managed to keep this scam running for over 2 years before people writing money checks finally paid attention to all the grumbling from the engineers and started to investigate. When they did, it all unraveled very quickly, of course. But in the meantime, a major new release of the company's main product had to be abandoned after spending those 2 years writing it on top of that messy stack - both its stability and its performance were deemed unacceptable. The whole thing was just scrapped.

From the company's perspective, it was certainly the most useless project anyone in it has ever worked on, and it cost a lot in terms of money. On top of that, the company lost quite a few great engineers who were forced to work on this thing, or to use it in product development.

Speaking for myself, though, I've learned a lot working on it. Most of it, in the end, was knowledge of the kind "why doesn't Java / .NET do it that way?", but even that can be useful, or at the very least, interesting. The money was good, too, especially for someone fresh out of college.