Why “Agile” and especially Scrum are terrible

This is a poor article on many levels. Even basic facts don't check out.

Agile didn't "grow up in web consulting", and it wasn't about dealing with finicky clients who couldn't be "managed". It came from enterprise both large and small, mostly not involved in web or consulting. In fact, it arguably started before software development did - see Kanban at Toyota.

Agile software development methodologies came from a real need to reduce the failure rate of software projects that was, even 10 years ago, closer to 50% than 0%. It attempted to provide ways to stop the average software project from running nearly 50% over budget. It waged war on the "big design up front" methodology handed to us by other engineering fields and acknowledged that in the real world, software development is often a wicked problem (http://en.wikipedia.org/wiki/Wicked_problem) that cannot be solved until it is solved. It acknowledged that requirements change, and software takes such a long time to build, often by the time a large design is built it already doesn't do what it needs to.

Almost all the statements the author makes are misleading, or misguided.

Violent transparency? It's a good thing that helps software projects succeed.

Atomic little user stories? They embody the divide and conquer philosophy to break down the author's ambiguous "long-term projects" into small chunks that can be understood, tested, and estimated. And delivered quickly.

Shared ownership? Promotes respect of the team, organisation, and customer. Helps get rid of bat-cave developers who can't acknowledge genius other than their own. Helps diffuse any blame for failure.

Social organisation? Has little to do with agile methodologies and a lot to do with the enterprises that implement them. Some do it well, some don't. Scrum doesn't dictate that a product owner or Scrum Master is more important than the engineer. Contoso Shiny Widgets Inc. does that. Just like they dictate whether experience and skill are valuable in their teams, and whether they listen to their engineers about technical issues that cause the kind of technical debt that is hard to solve with "good design".

Exit strategy? Short term? What? Use an agile process when it makes sense. Stop using it when it makes sense. Of course the process is designed to be there forever - they're tools to be used by people trying to solve real problems. The nature of those problems changes over time.

Lack of R&D? Software development is prima facie the D. The R? It's entirely possible to do that in iterations. Agile processes certainly don't remove R&D - spikes are there almost exclusively for R, and they're a first class citizen in the process unlike pre-agile. Perhaps the author refers to those 'long-term' projects that more often than not end up nowhere?

Technical debt? The author doesn't understand agile at all. Agile has two main tools to help manage technical debt - fast feedback loops, and encouraging development in small vertical slices. The best agile has even more - XP promotes TDD, not prematurely optimising, refactor mercilessly among other things. Basically universally accepted ways to improve the quality of software.

Crunch time? No! Agile promotes sustainable pace. To help avoid death marches. Heard of those? They've derailed careers for good.

I'm no big supporter of Scrum - it lacks the software design guidelines of e.g. XP, and it's been abused by some companies for their own purposes (probably those the author has worked for). But it has some fundamentally good ideas, and since Agile methods have been around enterprises small and large have improved on many measurable metrics. It's the best we currently have - come up with something better.

To save repeating myself: http://blog.binarymist.net/2014/01/25/essentials-for-creatin...

These are really good observations. If there's a common thread, I would say it's the intolerance for failure exhibited by managers who don't understand software development. I'm not sure that intolerance would be lessened by another system, whether it be waterfall or kanban, or ad hoc. Prior to agile, when failure happened, it tended to happen in a big way near the end of the project. But if a project were two or three years long, as is common in software, everyone could move on to other jobs after having spent two or three years without having to report progress every day or demo features every two weeks. A couple years in one job is pretty typical nowadays. So in some ways it was a more comfortable environment for engineers.

Agile was introduced so that failure could be amortized and tracked. It makes the development process more transparent so that mid-course management corrections can be made and the corporate ship can be steered around the icebergs instead of running blindly dead into them. But in order for it to work, management must be tolerant of small failures. If it's not, then scrum will become theater with failure swept under the rug, and you'll be right back where we were, with failure becoming apparent only near product launch, when the iceberg suddenly appears out of the fog too late to avoid it.

Now, it may be a valid criticism that agile expects too much from management, that most software company managers aren't competent enough to use it. But that pretty much says we're all doomed anyway, regardless of what system (if any) is employed.

I'd be interested in your thoughts on why you feel kanban is better, since my impression is that it is essentially the same process but without sprint intervals.

I think there are a few red flags here with the way you are doing scrum:

I have never heard of individual velocity measurements, they are wrong and should not be measured. I also think that burndown charts and velocity are for the team, not the stakeholders. This is because story point estimation is volatile and turning it into a feedback loop would turn this estimation into a meaningless thing.

Thus, there is room for transparency with the stakeholders in the sprint review and the setup, all else should be in the team's responsibility.

Scrum guides are usually very specific about the fact that the daily scrum is not for reporting.

Devops work should be priced in as a story in the sprint. If the Product Owner does not want to give such a story the proper priority, you should transparently explain how lack of such work will decrease sprint velocity in future sprints.

So kanban and scrum are fairly similar, but the difference is that with kanban, you don't have to estimate a point value to it, as time isn't the priority.

I view this as an advantage for two reasons:

- 1. Most non-technical clients view point estimates as absolute expectations. They can't comprehend an estimation in any other way. So if I can do 5 points a day, and I give a story 13 points, it's expected to be accomplished in ~2.5 days. If I exceed that amount of time, I've missed their expectations, and now I have a client who considers that work behind schedule.

- 2. Large complex problems can be solved without the pressure of accomplishing it within a finite deadline. I think this leads to more robust implementations, and helps prevent large amounts of technical debt. To compare, I have never seen a scrum project that didn't have a runaway amount of technical debt that lead to some insane scope creep in stories later on.

It has a downside of potentially hiding some problems, but I think it helps with individual responsibility when it comes to tasks. Every time I've used kanban, it's usually been for pretty short periods, but those periods were extremely productive and way less stressful.

I mean, this is just all my opinion, so take it with a grain of salt, but this is what my agile experience has been so far.