Agile Manifesto
With the popularity and proven success of Agile Manifesto, businesses and a wide range of project management professionals beyond the world of software have adopted its methods. In embracing the Agile Manifesto’s principles, organizations must ask themselves, “How can we structure ourselves to deal with uncertainty in product development effectively?”
What is the Agile Manifesto?
The Agile Manifesto for Software Development was a declaration of a unifying philosophy for frameworks like Scrum, Extreme Programming, and Feature-Driven Development (FDD). The Agile Manifesto greatly departed from the waterfall-style project management approaches that were widely in use prior to that time.
The Manifesto for Agile Software Development states:
“We are uncovering better ways of developing software by doing it and helping others do it.
Through this work, we have come to value:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
That is, while there is value in the items on the right, we value the items on the left more.”
Agile solutions come about as self-organizing, cross-functional Agile teams employ the appropriate practices for their context. But that doesn’t mean they do without managers. Managers are still needed to:
- Create an environment that allows for team success
- Make sure team members have the appropriate skill sets
- Provide guidance when teams can’t resolve issues for themselves
- Clear roadblocks and secure outside resources as needed
Who created the Agile Manifesto?
With the Wasatch mountains towering over them in Snowbird, Utah, 17 people gathered in early 2001 to discuss the future of software development. They included proponents of Extreme Programming, Scrum, Dynamic Systems Development Method (DSDM), Adaptive Software Development, Crystal, FDD, Pragmatic Programming, and others who saw the need for an alternative to “documentation-driven, heavyweight software development processes.”
From this group, 14 people became signatories of the Agile Manifesto, including:
- Mike Beedle, the founder and CEO of e-Architects Inc., a consulting company specializing in application development using distributed objects and internet technologies.
- Arie van Bennekum, who has been actively involved in DSDM and the DSDM Consortium since 1997.
- Alistair Cockburn, the founder of Humans and Technology, who is known for his extensive interviews with project teams.
- Ward Cunningham, a founder of Cunningham & Cunningham, Inc., who has served as director of R&D at Wyatt Software and principal engineer in the Tektronix Computer Research Laboratory.
- Martin Fowler, the chief scientist for Thoughtworks, an application development and consulting company.
- Jim Highsmith, the primary developer of the Adaptive Software Development Agile Method and author of a book by the same name.
- Andrew Hunt, a partner in The Pragmatic Programmers and co-author of The Pragmatic Programmer: From Journeyman to Master and Programming Ruby.
- Ron Jeffries, the proprietor of XProgramming.com, a consultant with Object Mentor, and the co-author of Extreme Programming Installed.
- Jon Kern, who is passionate about helping clients succeed in delivering business value through software development efforts.
- Brian Marick, a programmer and software testing consultant.
- Robert C. Martin, the president and founder of Object Mentor Inc., which offers XP and Agile process consulting, software design consulting, training, and development services to major corporations around the world.
- Ken Schwaber, president of Advanced Development Methods (ADM), who is dedicated to improving the software development practice.
- Jeff Sutherland, the chief technology officer of PatientKeeper, an MIT-based startup providing mobile/wireless applications to clinicians.
- Dave Thomas, co-author of The Pragmatic Programmer.
The Agile Manifesto story.
In the 1990s, before the Agile Manifesto meeting, software developers started looking for better, more responsive ways to work, mixing old and new ideas about Agile development and attempting to find the best combination for their purposes.
Their different methodologies focused on:
- Close collaboration between the development team and business stakeholders
- Frequent delivery of business value
- Close-knit, self-organizing teams
- Smarter ways to create, confirm, and deliver code
They started to develop frameworks that other teams could use, including Scrum, Extreme Programing, FDD, and DSDM.
During the 2001 Agile Manifesto meeting, the participants looked for commonalities in these different approaches. Discarding the things they couldn’t agree on, the participants codified the remaining points of agreement in the Agile Manifesto, providing a set of value statements and coming up with the term “Agile software development.”
The Agile Alliance was formed in late 2001, acting as a place for software developers to explore and share their ideas and experiences. Development teams were the first to use the Agile methodology, but it has since been adopted by other teams, particularly those who execute on projects that don’t have a clear scope and requirements at the outset.
As Agile became more widely adopted, an ecosystem developed that included the people doing Agile software development and others who helped them via consulting, training, frameworks, and tools.
The values behind the Agile Manifesto.
The four Agile Manifesto values are:
1. Individuals and interactions over processes and tools.
It is people who drive the development process and respond to business needs on the fly, so they take precedence over processes and tools. If the latter things drive development, the team becomes less responsive and able to meet customer needs.
2. Working software over comprehensive documentation.
The Agile Manifesto deemphasizes the documentation of the development process, which historically took a huge amount of time and often bogged down the team. By avoiding unimportant minutiae, Agile shifts the team’s focus from the process itself to the results of the process (actual working software).
3. Customer collaboration over contract negotiation.
In traditional project management methods, such as Waterfall, customers negotiate the product requirements in great detail before any work starts, and they’re typically involved only at the beginning and at the end. In Agile, the customer becomes an important collaborator throughout the development process, ensuring their input is incorporated, and the result meets their needs along the way.
4. Responding to change over following a plan.
Because ongoing adaptation isn’t built into the traditional software development process, change is an expensive headache. Agile embraces change, focusing on releasing a minimum viable product that can be evaluated and adjusted from iteration to iteration.
The principles behind the Agile Manifesto.
The 12 Agile Manifesto principles, expanding on the original manifesto, include:
- The highest priority is to satisfy the customer through early and continuous delivery of valuable software.
- The project team welcomes changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
- Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
- Business people and developers must work together daily throughout the project.
- The process builds projects around motivated individuals, giving them the environment and support they need, and trusts them to get the job done.
- A face-to-face conversation is the most efficient and effective method of conveying information to and within a development team.
- Working software is the most important measure of progress.
- Agile processes promote sustainable development. The sponsors, developers, and users should maintain a constant pace indefinitely.
- Pay continuous attention to technical excellence, and good design enhances agility.
- Simplicity is essential. This is the art of maximizing the amount of work not done.
- Self-organizing teams produce the best architectures, requirements, and designs.
- At regular intervals, the team reflects on how to become more effective and adjusts its behavior accordingly.
Relevance today.
Since the signing of the Agile Manifesto, the widely adopted product development approach has boasted many successes. It has given rise to other scaled Agile development processes, such as the Scaled Agile Framework (SAFe) and Large-Scale Scrum (LeSS), which help move Agile out of the software development arena and into other teams within the enterprise. According to Harvard Business Review, roughly 80% of companies are using at least some aspects of Agile in all of their principal business functions: research and development; production and operations; customer service and support; marketing and communications; sales; and even HR, finance, and administration.