The New Economics of Software Engineering

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. 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. - 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.