5 ways agentic engineering transforms agile practices

When software development is driven by AI agents, can software development teams still be agile?

The short answer is yes. Even in the age of agentic software engineering — a practice wherein orchestrated teams of AI agents plan, implement, test and document software — the agile development methodology remains important.

The longer answer is that agile techniques must evolve to meet the realities of agentic engineering. Practices that worked when applications were built solely by humans don’t always suffice when AI agents are doing much of the work.

Allow me to explain by discussing how agentic engineering is transforming software development, and what it means for the way developers practice agile.

A very brief history of agile software development

Agile is an approach to project management that emphasizes iteration and continuous improvement. Various agile frameworks (like Scrum and Kanban) exist that translate agile principles into specific practices. But at a high level, they all aim to make complex projects — such as designing, implementing, testing and deploying a software application — efficient and manageable.

The agile philosophy became very influential in the world of software development starting around 2000. Teams embraced it as an alternative to so-called waterfall development, a practice in which software projects often became mired by unforeseen delays and a lack of direction because developers tried to do too much at once. By breaking large projects into smaller chunks of work, agile promised a more efficient and reliable way to organize application development.

Agile has remained widely influential over the past several decades. Indeed, in many respects, it’s the foundation on which more recent software development trends, like the DevOps movement, were founded.

What agentic AI means for the agile methodology: 5 key takeaways

But over the past year or so, the introduction of a new type of technology — agentic AI — has upended some facets of agile development.

Agentic AI makes it possible to offload many aspects of software development, like code design and implementation, to AI agents, which complete the tasks autonomously. Hence, the rise of agentic engineering, in which the primary role of humans is no longer to be implementers, but rather to guide AI agents that serve as implementers.

Agile practices remain valuable in this brave new world. Software projects are still complex, and it’s important to maintain a consistent, manageable way of coordinating development work, whether it’s performed by humans or AI agents.

However, agentic engineering has a number of important implications for the way organizations implement agile techniques. Here’s a look at the most significant.

1. Redefining roles on the agile team

Traditionally, agile teams consisted of stakeholders who represented various functions or disciplines related to software development — like application design, code implementation, testing and documentation.

But in a world where AI agents can handle those functions largely on their own, the constitution of the agile team itself has changed. Instead of including different types of engineers, the agile team now consists mainly of humans who all share one basic role: Specifying what AI agents should do. In a sense, agentic engineering transforms all members of the development team into product managers, since their main purpose is to specify what a software product should do rather than building the code necessary to do it.

It remains important for these human “specifiers” to meet regularly, set clear goals and divide work into manageable units, as agile teams have always done. The major difference is that instead of delegating tasks to team members who have expertise in different areas of software development, the agile team is delegating to AI agents that specialize in varying functions.

2. Increasing the scope of agile stories

A core element of agile software development is the use of “stories” — meaning descriptions of what a new application feature or capability should do for end-users — as a way of guiding development work. In the past, agile teams typically organized their work around stories. They would define a story, then perform the work to implement it.

Stories are still a great way to define objectives in the agentic engineering era. However, because AI agents can perform more work in less time than humans, stories can be larger in scope. In other words, each story can correlate with a greater amount of change without risking situations where the team bites off more than it can chew at once.

3. New approaches to development concurrency

From the start, one of the core challenges of software development has been ensuring that multiple developers can work simultaneously without generating conflicting work. In other words, teams needed a way to manage concurrency during development operations.

In the context of agentic engineering, where AI agents can work much faster than humans, this goal has become even more important. So, have agile practices that can help to ensure concurrency while avoiding conflicts. For example, trunk-based development (in which application code is managed as a single “trunk” that all team members work on simultaneously is essential for ensuring that code implemented by one agent doesn’t break functionality built by another one.

4. Greater focus on end-to-end testing

When code evolves rapidly, as it does when AI agents write it, it becomes even more important to test the code regularly. This means, in part, performing unit tests, which validate whether an isolated part of an application works as expected. But even more critical are end-to-end tests that evaluate the functionality of an entire application and ensure it is suited for user needs.

It’s worth noting, too, that AI agents generally have a higher likelihood of implementing code that causes end-user problems, due either to hallucinations by AI models or simply because the agents don’t understand the overall context of an application in the same way that humans do. Nor are agents capable of thinking from the same perspective as human users. Rigorous end-to-end tests are vital for mitigating these risks.

5. Doubling down on software development metrics

Agile teams have long strived to measure the efficiency of their efforts using frameworks such as the DevOps Research and Assessment (DORA) metrics, which provide insights like how long it takes to complete a unit of development work and how often new application deployments fail. Quantifying software development operations using metrics like these helps teams determine where they’re falling short and where their greatest operational risks lie.

But in the age of agentic engineering, the ability to quantify the efficiency of operations has assumed newfound importance. That’s because AI agents add more moving parts to the software development life cycle and introduce new risks. Couple that with the fact that AI-assisted teams face pressure to move faster than ever, and it’s not hard to understand why they must carefully measure the outcomes of their operations.

Long live agentic engineering — and agile software development

Agile approaches to software remain as relevant as ever, because the ability to manage software projects efficiently is as important as ever. But to take full advantage of agile practices today, developer teams must fundamentally adjust many aspects of their approaches. They should still focus on flexible, iterative development strategies, but they must adapt practices like planning, testing and assessment to align with the speed and scale of the agentic era.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?