The new economics of software engineering

Code Quality Team Sep 15, 2026 / 58 min read

Episode 2

Link: https://thenextcommit.substack.com/p/episode-two-tim-ottinger?r=93lmrw&utm_campaign=post&utm_medium=web

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.