Episode summary Tim Ottinger brings decades of Extreme Programming, Agile and software-craft experience to the demanding end of agentic engineering. His work asks how agents can accelerate delivery without eroding the architecture and knowledge that consequential, long-lived software depends on. In this episode, Tim explains why an agent’s simplest path through a task can gradually erase a system’s design—and why the foundations of XP are gaining new leverage. We examine his use of small end-to-end slices, test-driven development and a distinctive checkpoint at which the agent stops before refactoring. Tim also shows how agents, tests and Git make ambitious legacy modernization more practical, how repository evidence can support better structural decisions, and why coherence became his eighth Code Virtue. The result is more than old practice with new technology: agents may allow teams to apply their best engineering disciplines more consistently and with fewer compromises. About Tim Tim Ottinger, known online as Agile Otter, is a long-time Agile practitioner and “old XP guy” who works with architecture and development groups at LexisNexis on technical improvement and safe agentic development. He co-authored Agile in a Flash, contributed the chapter on meaningful names to Clean Code, and has written extensively about software design, testing, refactoring, naming and team practice. In this episode * 00:57 — Introducing Tim Ottinger and his place in the early Agile community * 02:11 — Moving boldly—and safely—into agentic development * 03:10 — Code as knowledge representation, not only instructions * 04:32 — Why agents favour primitive solutions that gradually erase design * 06:04 — Architecture recovery, tripwires and technical safety * 07:03 — TDD, atomic commits and managing cognitive load * 09:07 — What is the agent equivalent of trained intuition? * 11:07 — Turning principles and heuristics into usable evidence * 13:18 — Finding hidden coupling in Git co-change history * 16:09 — Deterministic tools that help an LLM decide where to investigate * 20:51 — Small end-to-end slices and a disciplined test-first workflow * 23:30 — Why the agent stops when it proposes a refactor * 25:14 — Teaching a skill to reject coincidental duplication * 27:09 — Bringing books and articles directly into agentic work * 28:50 — Coherence as the eighth code virtue * 30:27 — Profitable and unprofitable intellectual labour * 33:25 — Preventing agents from reproducing legacy design problems * 34:13 — Refactoring an unfamiliar legacy codebase with agents * 38:07 — How agents change the economics of refactoring * 38:57 — Git makes ambitious structural experiments disposable * 39:39 — Why testing has become dramatically more viable * 40:28 — Learning software engineering when agents write the code * 43:31 — Focus, pairing and the art of doing one thing at a time * 45:02 — Combining hand coding, agents and mutation testing in training * 48:36 — Slicing and verification as critical developer skills * 50:41 — Why established Agile practices are gaining new leverage * 51:42 — Vibe-coded applications and choosing an appropriate engineering level * 54:12 — Turning a prototype into production software * 55:23 — A Short Guide to Naming and skills as a new publishing form Key ideas * Agents tend to choose solutions that are mechanically simple and locally safe, but repeated local exceptions can gradually erase a system’s design. * Fast implementation gives XP’s foundations—small increments, testing, refactoring and evolutionary design—new leverage rather than making them obsolete. * Small end-to-end increments keep work demonstrable and preserve opportunities to steer when complexity or consequence demands close control. * Tim stops the agent whenever it proposes a refactor. The transformation may be easy to automate, but deciding whether an abstraction represents something true about the system remains a critical judgement. * Agents, automated tests and Git make ambitious legacy experiments more practical. Work that would once have been too expensive to try can be generated, assessed, discarded or attempted differently. * Tim gives agents an evidence base through skills, architecture recovery and deterministic analysis of Git history, which can expose coupling that source dependencies miss. * Coherent code makes learning profitable: concepts, vocabulary and representations reinforce one another, allowing knowledge acquired in one area to remain useful elsewhere. * Books and articles can become agent skills, bringing established engineering knowledge directly into the coding session while leaving humans responsible for judging its application. * Agents amplify both trajectories. Strong tests, clear concepts and coherent design become easier to reinforce; shortcuts and weak structure can accumulate just as quickly. People and links * Tim Ottinger on Leanpub * Agile Otter blog * Tim Ottinger on X * A Short Guide to Naming * Time for an 8th Virtue: Coherence * LexisNexis * Industrial Logic Tools mentioned * Git * GitHub Copilot * Claude Code * Warp * SonarQube * Consensus This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit thenextcommit.substack.com
