I've been noticing the same thing since a few years ago so it's interesting to see that this may in fact be developing into a general trend and not just something specific to my niche (open source software development tools).

Some trends which I've observed over the past few years include:

- Bulky tooling which introduces unnecessary layers of complexity into projects which most developers ignore completely (they only see the pros and not the cons of many technologies).

- Strong herd mentality among developers is displacing critical thinking. There seems to be a mainstream consensus about which tools and practices are good and which are bad. Often, the consensus is either sub-optimal or downright wrong. Developers don't have the confidence to suggest tools to their teams which are not universally approved.

- Mechanistic use of 'design patterns' which make the code more complex than it needs to be. The design patterns are not applied correctly and they encourage developers to use many unnecessary abstractions which make the code more difficult to read and maintain. The code becomes over-engineered and disconnected from the problem domain - This makes is difficult to reason about.

- Over-reliance on project management gimmicks and processes instead of making developers responsible for different parts of the code. Instead of trying to hire trustworthy developers with a track record of producing high quality code and then trusting these engineers with the code that they write, companies try to minimize the amount of trust placed in developers - To achieve this, they rely on project management tools and processes which try to turn developers into replaceable cogs. As a result of this, developers feel no sense of responsibility over the code they write; in fact, in a desperate attempt to make themselves less replaceable, they write over-complicated logic which will be difficult for other developers to understand and will be more brittle.