Ruthlessly Helpful

Fadi Stephan and I presented our Back to the Future – A look back at Agile Engineering Practices and their Future with AI talk at AgileDC 2025. I think Back to the Future with AI is bit simpler.

In this blog post I explain what this talk is all about. The theme is to understand how AI is transforming the Agile engineering practices established decades ago.

Setting the Stage: From 2001 to 2025

The talk began by revisiting the origins of Agile in 2001 at Snowbird, Utah, when methodologies like XP, Scrum, and Crystal led to the Agile Manifesto and its 12 principles. We focused on Principle #9 “Continuous attention to technical excellence and good design enhances agility” and asked whether that principle still holds true in 2025.

Note: AI isn’t just changing how code is written … it’s challenging the very reasons Agile engineering practices were created. Yet our goal is not to replace Agile, but to evolve it for the AI era.

The Six Core Agile Engineering Practices

We reviewed six practices that we teach and coach teams on as we reflect on the adoption.

• The bottom row of Agile Engineering Practices [Continuous Integration (CI), Continuous Deployment (CD), and Automated Testing] has somewhat wide adoption.
• The top row [Test-Driven Development (TDD), Pair Programming, Collective Code Ownership] has very low adoption.

Note: that while CI/CD and test automation have spread widely, it is true TDD, Pair Programming, and Collective Code Ownership that remain rare. Yet these are the very practices that make the others sustainable.

Live Demos

Part 1: Fadi and I performed human-with-human TDD and pair programming using a simple spreadsheet project.

Part 2: I continued the process with AI assistance (GitHub Copilot), showing how AI can take over much of the “red-green-refactor” loop through comment-based prompting.

The Future of Each Practice (2026 and Beyond)

Next, we looked toward the future and made some informed guesses about where things might go.

Continuous Integration / Continuous Deployment

• CI/CD will evolve into self-optimizing, confidence-based pipelines.
• AI will monitor, secure, and heal systems autonomously.
• Developers will supervise rather than orchestrate pipelines.
• Infrastructure as Spec will replace Infrastructure as Code.

Pair Programming

• Pair Programming transforms into AI Pairing.
• Benefits like immediate feedback, early bug discovery, and elegant solutions remain.
• Peer review becomes continuous as humans review AI in real time.
• However, knowledge sharing among humans is lost, which is the key tradeoff.

Collective Code Ownership

• Collective Code Ownership shifts to AI Code Ownership.
• AI understands and can modify any part of the code, reducing reliance on individual experts.
• Developers can ask AI to explain or change code directly, improving accessibility and reducing bottlenecks.

Test-Driven Development (TDD)

• TDD evolves into something like prompt- and context- and spec-driven development.
• Instead of writing tests first, people will express customer needs and wants and expectations via prompts, and AI will execute the TDD loop.
• The iteration cycle becomes faster (60–80 loops/hour).
• Emphasis shifts from “testing” to iterative design through prompts.

Automated Testing

• AI can generate tests at all levels (unit, integration, UI) to ensure completeness.
• The long-sought testing pyramid balance of automated testing becomes achievable.
• Acceptance testing becomes central. Moving toward Acceptance Criteria or Behavior- or Spec-Driven Development using “Given–When–Then” style prompts.

Mapping the Old to New

Classic Agile Practice	Evolved AI Practice
Test-Driven Development	Prompt-Driven Development
Pair Programming	AI Pairing
Collective Code Ownership	AI Code Ownership
Automated Testing	Acceptance Spec–Driven Development
Continuous Integration	AI-Generated Test Suites
Continuous Deployment	Infrastructure as Spec

The New Human Role

As AI takes over mechanical and repetitive aspects, the human role shifts to:

• Supervisor & Policy Designer – governing AI systems and quality criteria.
• Context Setter – providing domain understanding and intent.
• Just-in-Time Reviewer – giving oversight and feedback during AI collaboration.
• Explanation & Change Requester – asking AI to explain or modify code.
• Spec Author – defining business expectations and acceptance criteria.

Closing Message

We concluded the talk by emphasizing that Agile’s core values of collaboration, learning, and delivering customer value will remain essential. However, the means of achieving technical excellence are evolving rapidly. Rather than resisting change, developers should co-evolve with AI, embracing new forms of collaboration, feedback, and craftsmanship.

The Agile practices of 2001 are not obsolete; but in the age of AI, they are being reborn.