Agile at 25: How We Lost the Plot and What We Can Do to Reclaim It

Almost seventeen years ago, I embarked on my Agile journey, full of hope and excitement. Back then, Agile was a breath of fresh air.. a radical departure from the rigid, bureaucratic, and soul-crushing processes that dominated software development. It promised a better way: collaboration over control, adaptability over predictability, and people over processes.

In 2013, I bought Robert C. Martin’s Agile Software Development, a book written by one of the original signatories of the Agile Manifesto. Little did I know that, in the years to come, Agile would become the very thing it sought to replace: a tool for micromanagement, a process to measure and control developer productivity, and a buzzword stripped of its original intent.

Today, as I look back on nearly two decades of Agile, I can’t help but wonder: How did we get here? And more importantly, how do we reclaim the spirit of Agile?

The Promise of Agile: A Revolution in Software Development

When the Agile Manifesto was written in 2001, it was a response to the inefficiencies and frustrations of traditional software development methodologies. Waterfall, with its linear phases and heavy documentation, often led to missed deadlines, bloated budgets, and software that failed to meet user needs. The Agile Manifesto was a call to arms, emphasising:

Individuals and interactions over processes and tools.

Working software over comprehensive documentation.

Customer collaboration over contract negotiation.

Responding to change over following a plan.

At its core, Agile was about trust, empowerment, and delivering value. It was about creating an environment where developers could thrive, where teams could collaborate effectively, and where the focus was on solving real problems for real users.

The Perversion of Agile: From Empowerment to Control

Fast forward to today, and Agile has become something entirely different. In many organisations, Agile is no longer a philosophy or a mindset—it’s a process, a tool, and, in some cases, a weapon. Here’s how we lost the plot:

1. Agile as a Productivity Hammer

Stand-ups, sprints, and velocity tracking were meant to help teams self-organise and improve. Instead, they’ve become tools to measure and control developer productivity. Teams obsessed over burn-down charts and velocity metrics, using them as a stick to push teams to deliver more, faster. The result? Burnout, stress, and a culture where quantity trumps quality.

2. The Ritualisation of Agile

Agile ceremonies—stand-ups, retrospectives, sprint planning—were designed to foster communication and continuous improvement. But in many organisations, these ceremonies have become empty rituals. Teams go through the motions, ticking boxes without truly engaging or reflecting. The spirit of collaboration and learning is lost.

3. The Rise of Agile Industrial Complex

The Agile industry has exploded, with certifications, frameworks, and consultants promising to “implement Agile” in your organisation. But this commodification of Agile has turned it into a one-size-fits-all solution, often imposed top-down without regard for the unique needs and culture of each team.

4. The Neglect of Technical Excellence

One of the 12 principles of the Agile Manifesto states: “Continuous attention to technical excellence and good design enhances agility.” Yet, in the rush to deliver more features faster, technical debt is often ignored. Teams are pressured to cut corners, leading to fragile, unmaintainable codebases that undermine long-term agility.

5. The Illusion of Productivity Metrics

Today, it’s common for organisations to link JIRA tickets, pull requests, and code repositories to dashboards that track "productivity." They look at metrics like:

Number of tickets closed: Did the developer resolve enough issues this sprint?

Lines of code written: Did they add enough code to prove they’re working hard?

Commit frequency: Are they pushing code often enough to show they’re active?

On the surface, these metrics seem objective and measurable. But in reality, they create a false sense of productivity. Developers are incentivised to:

Prioritise quantity over quality: Writing more lines of code doesn’t mean you’re solving meaningful problems. In fact, it often leads to bloated, unmaintainable code.

Game the system: Developers might break tasks into smaller, trivial tickets to inflate their "tickets closed" count or make unnecessary changes to boost their commit frequency.

Avoid refactoring and cleanup: Refactoring or deleting code doesn’t add lines to the repository, so it’s often deprioritised, even though it’s critical for long-term maintainability.

6. The Human Cost of False Metrics

When tools like JIRA, Github, Gitlab are used to measure productivity, they reduce developers to cogs in a machine. Instead of being valued for their creativity, problem-solving skills, and ability to deliver meaningful outcomes, developers are judged by arbitrary metrics that have little to do with the quality of their work. This creates a toxic culture where:

Developers feel pressured to prove their worth: Instead of focusing on solving real problems, they’re constantly trying to "look busy" or "show progress."

Collaboration suffers: Teams compete for visibility rather than working together to deliver value.

Innovation is stifled: Developers are discouraged from taking risks or experimenting, as these activities don’t align with the metrics being tracked.

The Irony of Agile: A Tool for Captivity

The greatest irony of Agile is that it has become a tool for captivity rather than liberation. Developers, who were meant to be empowered by Agile, now find themselves trapped in a system that measures their every move, demands constant visibility, and prioritises output over outcomes. The very principles that were supposed to set us free have been twisted into chains.

Original signatories of the Agile Manifesto envisioned a world where developers were trusted professionals, capable of self-organisation and creativity. Instead, we’ve created a world where developers are treated as resources to be optimised, their productivity reduced to numbers on a chart.

Reclaiming Agile: A Call to Action

So, where do we go from here? How do we reclaim the spirit of Agile and ensure it remains true to its original intent? Here are a few thoughts:

1. Focus on Values, Not Processes

Agile is not about following a set of prescribed practices—it’s about embracing a mindset. Instead of obsessing over ceremonies and metrics, focus on the values and principles of the Agile Manifesto. Ask yourself: Are we truly collaborating? Are we delivering value to our customers? Are we responding to change?

2. Empower, Don’t Control

Trust your teams to do their best work. Give them the autonomy to self-organize and make decisions. Resist the urge to micromanage or use Agile practices as a means of control. Developers should feel empowered to challenge meaningless metrics and advocate for meaningful work. If a metric doesn’t align with the team’s goals or values, it’s okay to question it or even abandon it altogether.

3. Prioritise Technical Excellence

Agility is impossible without a solid technical foundation. Invest in practices like continuous integration, automated testing, and refactoring. Encourage a culture of craftsmanship and pride in the work.

4. Reject the Agile Industrial Complex

Don’t let certifications and frameworks dictate how you work. Tailor Agile practices to fit your team’s unique needs and context. Remember, Agile is a means to an end, not an end in itself.

5. Reconnect with the Human Element

At its heart, Agile is about people.

6. Measure Outcomes, Not Outputs

Instead of tracking lines of code or tickets closed, focus on outcomes that matter. Are we delivering value to customers? Are we solving real problems? Are we improving the quality and maintainability of our codebase? These are the metrics that truly matter.

7. Celebrate Code

Recognise and reward the importance of refactoring, cleanup, and technical debt reduction. Create a culture where clean code is valued. After all, a clean, maintainable codebase is the foundation of agility.

8. Use Tools for Collaboration, Not Surveillance

JIRA, Github, Gitlab should be used to facilitate collaboration, not to monitor developers. Encourage teams to use these tools to communicate, share knowledge, and work together effectively.

9. Focus on Flow, Not Metrics

Agile is about delivering value in a sustainable way. Instead of obsessing over individual productivity metrics, focus on optimizing the flow of work through the team. Are we delivering value consistently? Are we improving over time? These are the questions that matter.

Conclusion: Agile Is Not Dead, But It Needs Saving

Agile is not dead, but it is in danger of being lost. The principles that once inspired a revolution in software development have been diluted, distorted, and, in some cases, discarded. But it’s not too late to reclaim Agile. By returning to its roots.. by focusing on values, empowering teams, and prioritising people over processes.. we can ensure that Agile remains a force for good in the world of software development.

Let's stop measuring the wrong things. Let’s stop reducing developers to lines of code or tickets closed. Let’s stop using tools as weapons of control.

As someone who has lived through the rise and fall of Agile, I urge you to reflect on how Agile is being used in your organisation. Are you staying true to the spirit of the Agile Manifesto, or have you lost the plot? The choice is ours to make.