This article is based on a first-person account originally published on TechTarget.com covering the Agile Alliance Technical Conference (AATC) 2017.
Background: Why a Separate Technical Conference?
The Agile movement has firmly taken hold in software development. Standups, user stories, and sprints are now standard vocabulary across most engineering teams. Yet over roughly four years, the flagship Agile Alliance conference — which grew from around 900 to 1,500 attendees during that period — steadily reduced its technical content. The DevOps track continued to grow, but sessions on programming and testing drew smaller audiences. Fewer technical practitioners attended, fewer attended technical sessions, and organizers responded by scheduling fewer technical talks the following year — a self-reinforcing cycle.
Something had to change. In 2016, the Agile Alliance launched the Agile Alliance Technical Conference (AATC) as a dedicated venue for practitioners who wanted to go deep on engineering craft rather than process or management frameworks.
What Happened at AATC 2017?
The 2017 edition was held in Boston and drew approximately 300 attendees. The opening keynote was delivered by Ron Jeffries and Chet Hendrickson, two of the original signatories of the Agile Manifesto and long-time advocates of Extreme Programming (XP). They performed the bowling game kata — a form of deliberate practice in which a programmer (or pair) solves a well-defined problem repeatedly to build muscle memory for a specific skill.
In this case, the skill was test-driven development (TDD). Along the way, the two discussed code quality, sustainable pace, pair programming, and what “modern” Agile engineering looks like in practice. Because Jeffries and Hendrickson bring fresh nuance to the kata each time they perform it — despite having done it for over a decade — it still resonated as genuinely new material with the audience.
Other sessions at AATC 2017 covered:
- A keynote on Extreme Programming, celebrating its twentieth year as a methodology
- Fundamentals of test-driven development
- Practical refactoring techniques
- Writing and maintaining clean code
Notably absent from the three-day agenda: stories, standups, sprints, or discussions of trendy infrastructure tooling. The conference was deliberately focused on coding craft.
The Technical Renaissance: Are Agile Engineering Practices Going Mainstream?
At first glance, the fact that a technical conference needs to re-teach TDD and refactoring — practices that have existed for twenty-plus years — can look like a failure. It could be read as evidence that the industry is “post-Agile” in the worst sense: teams adopted the ceremonies while abandoning the hard technical disciplines.
But there is a more optimistic interpretation. Linda Cook, an Agile Alliance board member, explained the conference’s intent the evening before it opened: the AATC was designed to reach a different audience — practitioners who were not plugged into the conference circuit, who had not been exposed to XP or TDD through the usual channels, but who were hungry to learn and improve their craft.
Filling a hotel ballroom in Boston with developers eager to learn TDD and refactoring suggests something important: Agile technical practices may finally be reaching the mainstream, rather than remaining the province of a small community of early adopters.
The Diffusion of Innovation Lens
Sociologist Everett Rogers’ diffusion of innovation model describes how new ideas spread through a population across five groups:
- Innovators — create and experiment with new ideas
- Early Adopters — willing to try things with minimal evidence
- Early Majority — adopt after seeing others succeed
- Late Majority — adopt once a practice is well established, often under peer pressure
- Laggards — adopt only when the old approach is no longer viable, or not at all
Viewed through this model, the AATC audience looked like the early and late majority arriving for Agile engineering practices. These were not the innovators who invented TDD in the 1990s, nor the early adopters who championed XP in the 2000s. They were developers at mainstream organizations who had heard about these practices, sensed they were falling behind, and wanted structured help getting started.
Seeing 300 peers — all at different stages of the same journey — in one room is a powerful signal. It validates that the struggle is common, and that the practices are learnable. That is precisely the environment in which a late majority adopts a new approach.
Proto-Agile, Agile, and Post-Agile: Where Does the Industry Stand?
Each morning at AATC, a small group gathered for Lean Coffee — an open-agenda conversational format where participants propose topics, vote on priority, and then discuss in time-boxed rounds. One recurring theme was the state of technical practices: specifically, “Is Extreme Programming dead?”
Woody Zuill, a well-known practitioner and pioneer of Mob Programming, offered a useful three-stage framework at the table:
- Proto-Agile: “We know what we had before isn’t working, and we are discovering new things.”
- Agile: “We actually understand these modern methods and do them well.”
- Post-Agile: Continuing to innovate beyond established Agile practice — not abandoning it.
Zuill’s position was direct: XP cannot be dead, because he uses it every day. “Post-Agile” in the healthy sense means teams have internalized the core practices so deeply that they no longer need to label them — not that they have abandoned them in favor of stand-up theater.
What This Means for Engineering Teams
The signal from AATC 2017 is nuanced but important for anyone leading or working on a software engineering team:
- TDD, refactoring, and clean code are not niche or outdated — they are skills that a large segment of the industry is actively trying to acquire right now.
- The gap between process adoption and technical discipline is real. Many teams run sprints but do not practice continuous integration, TDD, or refactoring. Closing that gap is one of the highest-leverage investments an engineering organization can make.
- Deliberate practice works. Katas, pair programming exercises, and structured code review are how these skills transfer — not just by reading about them.
- “Post-Agile” is not an excuse to stop improving. If your team has abandoned technical practices in the name of pragmatism, the AATC data suggests you are likely in the early or late majority who have adopted Agile ceremonies without the engineering foundation that makes them effective.
Conclusion
The Agile Alliance Technical Conference 2017 offered a clear-eyed snapshot of where the industry stands: technical practices like TDD, refactoring, and clean code are no longer strange or radical ideas, but they are also not yet universal. They are in the process of diffusing from their innovative origins into the mainstream — and a growing number of developers are actively seeking to learn them.
For DevOps practitioners, this matters directly. The feedback loops that make continuous delivery reliable — fast automated tests, small refactored functions, clean interfaces — depend on exactly these skills. The infrastructure may be ready; the question is whether the engineering practices are keeping pace.