This February 13th will mark a decade since the creation and signing of the original Agile Manifesto. The lean development thought leaders who came together that weekend ten years ago similarly pushed forward their entire industry by uniting behind a common set of beliefs.
At times I like to imagine that Snowbird event as the software-world equivalent of the infamous story in which a group of politicians in a cigar-filled backroom in Ohio decided that Warren G. Harding was about to become America’s next president.
Over the last few years there have been countless books and conferences designed to help flesh out the original Agile Manifesto statements. The Manifesto became a symbol for developers whose voices were not being heard in the process of developing software products.
Now, a decade later, it is a commonly held belief that following Agile development is the preferred way of building a software system. This was not always the case, and I am appreciative of this renegade history as well as those initial forward-thinking giants at Snowbird.
A few years ago James Shore wrote a great blog post entitled The Decline and Fall of Agile, in which he brought up ideas of technical debt and code quality that were lacking in Agile development.
He points out that the Agile practices have left us an approach to writing code without necessarily specifying a method or process of writing that code. If this is the case, let us pick up another model or metaphor of transformation and allow our reactions to Agile development evolve the way postmodern artists pushed aside, reacted to, and grew out of the failures, experiments, and limitations of modern art.
Let us also discuss what Agile is missing, put it under the microscope, and try to get our brightest and most enthusiastic minds solving its problems. Let us call Agile “dead” as the dramatic impetus to intelligently investigate those issues with a mind towards exploration.
The Agile Manifesto’s place in transforming our industry is unquestionable, but it has taken us as far as it can. As David Berman writes, “the dead do not improve.” Agile is filled with revolutionary ideas, but the revolution is over.
My post-Agile world is software craftsmanship. Not coincidentally it is a movement led by some of the same members who attended the original Agile meeting a decade ago. If Agile software taught us how to build products through its values, software craftsmanship’s values are teaching me how to write great code.
At the Software Craftsmanship Summit in 2008, Brian Marick proposed that one of the values of software craftsmanship is to “treat code as an end, not just a means.” This Kantian phrase has resonated in my mind a million times since then as an apt mantra for software craftsmanship.
Write great code and everything else becomes easier. It is easier to set expectations with the customers or product owners when you are not dreading the mess of code that you have to wade through.
It is easier to train developers when the code base is filled with code you want emulated. It is easier to plan a business around the code base if it is malleable and tested.
I’d like to suggest that we study the various cracks and strains of Agile not simply to hypothesize ways in which Agile might be fixed, but instead to allow those imperfections to present us with our next big challenge: the pursuit of great code.
This is software craftsmanship for me. Let the quest to define and reproduce quality endure. The King is Dead. Long Live the King.