From my understanding, Agile was developed by developers sick of the rigid and static waterfall model and the problems caused by such a model. In discussions on

From my understanding, Agile was developed by developers sick of the rigid and static waterfall model and the problems caused by such a model. In discussions on Agile I often see a lot of complaints about managers not doing it right, wrongfully expecting developers to commit to certain things and then actually deliver on that. As a manager, I must say I feel a little bit offended. Not only did the developers specifically ask for Agile in order to fix the issues with late projects that doesn't fulfill their purposes, they are then telling us in threads like these it's our fault. What I read from these comments is a lack of understanding and ownership of the problem, and capability to solve it. To sum it up: Problem: Missed deadlines/cost overruns and lack of success in fulfilling the actual problem. Solution in theory: The theoretical, engineering/developer, solution to the problem: Less commitment and more flexibility. Basically set the right expectations that we'll drive in the wrong direction and then need to correct it rather than continue because that's what's originally agreed. The "solution" in reality: Less commitment and less responsibility and ownership of the business situation (which hasn't gone away and never will). What happens: Less focus on the original problem. Developers thinking that deadlines and not fulfilling the purpose is even more something that is the problem of managers, and not developers. When shit still goes south because developers are still often not any good at tackling the original problem (although the promise was made by them it'll be better if they run the show), they (as obvious from the comments here) still put the blame on management. In other words. Developers thought they were better at solving a problem than a person in a role dedicated to solving those types of problems (compared to developers where it's not in focus at all), still blames management when their proposed solution failed. Ironically (but very logically) the least capable are the ones complaining the most and owning the problem the least. What I believe has caused the situation: An immature industry (due to young age), a complex problem and a lot of demand for developers making companies/managers not having enough leverage to be able to pressure devs into focusing on the right thing/development (the rockstar mentality). Plus of course inexperienced managers that doesn't dare to take control over the situation. The worst part of it all is that it takes away focus from the actual problem, and hides a lot of incompetence (both on the manager and the developer side) which I find is often a root cause (and my understanding is that science agree with me - which and how correctly you use a specific methodology/process is not strongly correlated with overall success. PS. I still believe Agile is good in many cases and there a lot of smart developers doing Agile with great results, but there are equally a lot of people who believe they at better at solving problems they are perhaps the least capable of. What's really sad is that many of those people are actually quite good developers.