TL/DR: devs don't hate agile, they hate non-technical enterprise middle-managers and the people who hire them.

If you've ever worked in an enterprise that embeds non-technical managers on technical teams to run the show, you've probably seen some flavor of the following:

The manager starts with good intentions. They try to learn the product, the team, the rough implementation outline, etc. Over time, due to the delta between their understanding and the reality on the ground, their job devolves into:

1. Attending ill-conceived meetings that generate mountains of noise because they demand the impossible, the nonsensical, or the redundant.

2. Communicating this noise to their team through a series of terse bullet points / JIRA items / trello lists / whatever

3. Assigning a senior+ engineer on the team to reconcile their list with reality, and then to do the actual work of translating product requirements into meaningful units of work for the more junior engineers on the team.

4. Scheduling more meetings to reconcile the original list of items with the list of items that now makes nominal sense, producing more noise because people get upset about items they didn't understand in the first place changing, or feeling like they've "made commitments to stakeholders" that they now have to apologize for or backtrack on, etc.

5. Scheduling meetings to handle the "drama" that emerged when manager A and manager B had an ego-fight over some insane laundry list of garbage. "Going to the mat" for their "stakeholders," etc.

6. Scheduling more meetings with engineers to "fix the process"

7. Scheduling more meetings to hire replacements for the engineers who burned out doing both the manager's job and their job while being held accountable to the latter while hobbled by the former.

8. Rinse, repeat. Note that the cycle begins afresh with every new manager, who in my experience have at most a 1-year lifespan on a team because they were either good enough at looking important in meetings and showing up for 70 hours a week that they got promoted to the next shit-show, or they "moved on to other opportunities".

This whole ouroboros of noise gets wrapped up in whatever management terminology is prevalent at the company.

In this situation, the team loses time and energy every time the manager does a thing. They either have to stop working to correct the noise (which if left uncorrected festers and becomes worse) or stop working to attend an unnecessary meeting to make sure it doesn't go off the rails, or whatever.

Agile, which is really just a cover-all in enterprise for
a "continuous planning because we don't ever really know what we're doing" strategy, multiplies this noise many times over because error compounds upon error multiplicatively, and it creates a lot of opportunities for error by creating many decision points.

(Edit: there's a darker version of this, which I've personally witnessed, where no one pushes back on the insanity because the team is very weak. This is how you get teams serving static web pages at 2.5 transactions a minute on giant web service frameworks that cost tens of thousands of dollars a month to "operate", or pick your daily wtf)