AI–Driven Development

AI writes software faster, cheaper, and better than humans, but it also hallucinates and misinterprets us. Agile teams remain essential to keep AI on the road even when they no longer drive.

There's no such thing as straight and level. [While] things seem to be going perfectly, you don't take your eyes off the road. You must always be prepared to move a little this way, a little that way. Sometimes a completely different way. -- Kent Beck

Human developers hallucinate too. We just call their hallucinations bugs. That's why Beck's test-first, test-driven, continuous integration became the critical enabler for high-performing Agile development. Without his XP practices, bugs drove the costs of change exponential on Agile projects. With them, these costs went linear. That math was what truly made "Agile" agile.

The Three Amigos + 1

XP pioneered Test-Driven Development, which turned the traditional Analyze-Design-Build-Test workflow on its head: Analyze-Test-Build-Design. In TDD, Analysis generates executable Tests, developers Build the simplest solution that passes these, then Design by refactoring all their code to form the simplest system that still passes all old and new executable tests. Beck called the rinse-and-repeat cycle of this workflow "Continuous Integration".

A decade after XP, Behavior Driven Development was coined by Dan North and popularized in John Ferguson Smart's books. BDD elevated the TDD workflow from code functions to product behaviors. It introduced Gherkin, a simple natural language format that made business specs executable as tests – along with tools to automatically visualize the compliance of the specs with actual system behaviors. BDD also introduced the famous "Three Amigos" workflow where analysts, testers, and developers collaborate on Gherkin acceptance criteria to drive new product behaviors.

Gherkin makes a natural way to align technical and non-technical people with AI too. We still need the human amigos to review BDD test-step implementations, solution code and integration choices to make sure they meet business intents. But Gherkin enables humans and AI to align on product behavior in ordinary human language, and evolve this alignment iteratively while maintaining linear costs of change.

AIDD Workflows

Each step of this AIDD workflow involves collaboration between AI and BDD's human amigos. The humans still collaborate with each other too. While every step in the Three Amigos workflow could in theory be generated by an AI agent alone, without humans to reality-test AI outputs and collaborate on product design decisions these loops turn into a hallucinatory positive-feedback generator. Like the howl of a speaker plugged into its own microphone ... Conway's Law gone mad.

But this first picture doesn't cover the really massive potential of AIDD to surpass BDD workflows because it doesn't consider meta level collaboration between the human amigos and AI agents. That's to say, each of these humans can have an AI agent of their own, which they constrain with specs on HOW to produce Gherkin specs relevant to their function. We still need the humans in the loops for the same reasons as above, but this way the pairing of amigos with AI agents becomes enormously more productive.

In later articles in this series we'll see how we can focus development teams on ever-changing throughput constraints through breadth-first, scientific design patterns pioneered by the XSCALE Alliance. These patterns economically derive per-feature acceptance criteria from business constraints by way of the critical Agile/XP principle of YAGNI: You Aren't Gonna Need It. And this is how we break the mad self-reinforcement AI loop - by forcing all the AI agents to fit their work to a growing body of Three Amigos Gherkin constraints.

AIDD for Legacy Systems

Even when legacies lack adequate documentation and tests, AI can rapidly generate Gherkin regression suites based on the history of the legacies' codebase as correlated with historical logs of system behavior along with historical kanban and email archives that track the human conversations that produced these things. While actually saying that out loud sounds mind-boggling to us olde-timey developers from the 2010s, such analysis is clearly within capabilities GPT demonstrates today.

Where such logs and histories aren't available or reliable, AI can still rapidly and cheaply generate probes into live systems to capture both UI transactions and the resulting database transactions en-masse. By correlating these with each other in a RAG LLM it can generate Gherkin specs that express the key invariant business relationships between the behaviors of these probes.

Performing such analysis is prohibitively expensive for humans. While we can clearly train AI to do it, the qualities of AI execution for such purposes remain largely untried. In any case, these generated Gherkin specs will require systematic review by our human amigos to assure they cover over all business intents and unhappy-path behaviors without AI hallucinations getting baked into the spec-step implementations Ken-Thompson-style.

Such human reviews will be much more expensive than AI generation of Gherkin regression suites, but still enormously cheaper than continuing to employ humans to maintain legacy codebases. Enabling AIDD to systematically replace these with modern test and solution code effectively linearizes their costs of change too. Indeed this same regression-test automation is applied to commercial AI models themselves to keep their behaviors within ethical and functional guidelines - despite the fact that we have zero documentation or human-readable code for them.

From AIDD to Continuous Alignment

The rightmost step in the AIDD workflows in the diagrams above automate Continuous Integration of the work products of interdependent teams. As this includes our executable but still human-readable Gherkin specs, this seems to offer a way to continuously align these interdependent teams without face-to-face communication between them.

And that's a problem.

While AI-driven alignment of work on the codebase is essential to efficient collaboration, without also aligning the human members of different teams with each other this risks generating huge confusion. We want the humans to make and moderate rational decisions about system behaviors without constantly tripping over each other's different ideas. We can't rely on AI to do this but mainstream Agile methods can't keep up with the AI flows either.

In upcoming articles in this series we'll explore a range of Agile Alignment methods to solve this problem. Part of the way such continuous alignment can work is extending the shared fabric of Gherkin tests to form executable contracts for workflows between interdependent teams at every level of the organization – root and branch, not just at operational leaves

And that's why the next article in this series will start by integrating AIDD with Leadership as a Service. If you'd like to help us keep this series of articles honest, come join in at LinkedIn's new AI & Agile Alignment group.