Why AI *will* increase the need for good Agile software development

Two things happened yesterday which prompted this post.

First was a very experienced and knowledgeable Agile person saying that he thought agile as a whole was in decline. This was prompted by the recent PMI takeover of Agile Alliance and a host of "Agile is dead" posts.

Second I read a bit of Forrester's 2025 State of Agile Development report.

These opinions, combined with my own experience at Everest working with a team developing an AI app, made me think about developer workflows, developer productivity (that Pandora's Box of horrible assumptions) and, generally, what good software looks and feels like.

What do I mean by good Agile software development?

I chose these words deliberately. I tend to think that this phrase aligns quite well with the practices of Extreme Programming (XP). At Everest we are not explicitly an XP shop but, mostly, our developers use XP practices in most projects. We pair a lot. We focus on tests, sometimes using TDD. We like small releases and slice aggressively to make our work easier to manage. We integrate our software continuously. And we (mostly) play the planning game.

Of course, our clients may use Scrum, Kanban, SAFe or a myriad of other approaches and so we will work with them wherever they are. But our practices, in collaboration with them, tend towards the list above.

There's more to it, of course. Creating great collaboration. The right environment to do work. Improving the flow of work. But, for this article, I'm going to focus in on a few practices that we think are part of good software development.

The Impact of AI

Of course I mean Generative AI, and mostly Large Language Models. That has become the new shorthand. We pretty well ignore all other forms of machine learning, symbolic reasoning, non-generative vision and all other forms of AI with this new shorthand. I find it frustrating but this is 2025 ... not 1990.

Pairing with AI

One of our developers was an early adopter of ChatGPT for code suggestions and has managed to develop a style to continuously pair with different AI assistants. One of the early findings from this experiment was the adoption of not one, but many, AI assistants for different use cases (like generate example code, solve this problem, complete this code as different ways of using an LLM). This is not really surprising for 2 reasons. First that we have found that different foundation models understand software code and generate code differently. Second, the understanding that pair programming is not just one technique. There are many different ways to pair. For example we pair to think about how we solve a problem. Which algorithm should we use? Why would one approach be better than another? We could pair in a TDD style.

Test-First Development

Another example of pairing with AI is where developers are doing red-green refactor TDD with an AI assistant. We have also been successful with this approach in our projects. There are many different ways to partner with AI on testing software so, overall, we are seeing that today's AI is helping us to deliver better quality software, more relevant tests and better designs (meaning modular software designs that are more testable).

Slicing

Generating new code with an AI assistant seems to work best when the scope is small and there is a lot of context included. This suggests that writing code with AI is best done in small slices. So, whether it is a quest to improve the code being generated, or a need to break down the problem for the AI to work effectively, I tend to believe that working with AI will result in more finely sliced software.

Continuous Integration

To be fair I don't think AI changes the need for CI in any way. I do think better automated tests make deployment easier. AI makes developing automated tests easier. And smoother deployment with automated tests enables faster deployment, which means there is a need to integrate code more often. So, indirectly, AI makes it easier to do CI.

The narratives above, to justify pairing, TDD, slicing and CI, are very superficial. There is a lot more involved and these are broad generalisations extracted from a few experiences. But I'm gonna put this out there as a proposition and wait for criticism to flood in.

Conclusion

Whilst AI will inevitably generate a lot of "crap" code and it may encourage "sloppy" practices, I think it will also enable developers to write better code, better tests and I do think the "cream will rise to the top". Meaning that people will become more discerning over the quality of software development work.

Whilst I don't believe that CEOs will suddenly jump in and embrace XP practices, I do think that AI will enable XP developers to do a better job and get more work. Therefore, AI will indirectly enable better agile software development!