Robert C. Martin, known as Uncle Bob, joins Matt Pocock to discuss software fundamentals in the age of coding agents. Martin argues that agents can write quickly but still get trapped in messy code. His answer is to give them automated checks and focused jobs, while keeping a human involved in architecture.

Checks that agents can afford to run

  • Martin revisited CRAP scores, which combine test coverage and a function’s decision-path complexity. He also uses mutation testing: deliberately change code and check whether the tests catch the changes. A change that survives points to a possible gap in the tests.
  • He says agents can do the repetitive repair work that once made these checks impractical for him. He spot-checks code and scores, but his goal is to rely less on line-by-line human review.
  • Written instructions alone were unreliable in his experience. He prefers a short prompt plus checks that force the agent to repair a failure. Pocock contrasts this with trying to steer an agent using ever-longer instruction files.
  • These checks have a cost. Martin says his process can turn a five-minute single-agent task into an hour-long pipeline. He estimates that the result still beats the half-day a person might take. Those are his informal comparisons, not a controlled benchmark.

A pipeline of focused jobs

  • A specifier turns a human story into given/when/then acceptance criteria and a user-facing QA procedure.
  • A coder writes the implementation and tests. A cleaner reviews and reduces complexity. A hardener runs mutation tests and strengthens coverage. A final QA agent turns the procedure into an executable system test.
  • Martin says fresh, narrow contexts help each agent focus. Parallel work is another advantage, but startup and handoff costs add up. Pocock favors the separation between implementation and review while expressing skepticism about elaborate agent organizations.
  • Passing a metric is not proof that the software is correct. The discussion is a description of Martin’s evolving workflow, not an independent validation of it.

Architecture still needs attention

Martin says his early agent-built systems had frightening module structures. He inspected their dependencies, redesigned the boundaries himself, and asked agents to implement the changes. He also built an architecture viewer and a checker for allowed dependencies. He has not yet found a satisfactory way to automate the architectural design itself.

Pocock brings up John Ousterhout’s idea of a deep module: a small interface hiding substantial implementation detail. Both speakers argue that clear boundaries help agents focus, as well as helping people understand a system.

Human values, different disciplines

  • Martin experiments with a higher complexity threshold for agent-written functions than for human-written ones. He stresses that he is still looking for the right threshold.
  • He values tests but does not insist agents follow his own line-by-line test-driven development ritual. His distinction: retain the desired quality, while adapting the working discipline to the worker.
  • He is wary of elaborate upfront specifications after his own attempts broke down. He wants to try short cycles of a story or two, feedback and architectural adjustment. He describes the specifications as temporary and points to the resulting system as the thing to examine.
  • For newcomers, Martin proposes writing code first, then practicing tasks under the same checks used for agents before supervising them. Pocock asks how companies will make room for that apprenticeship. Neither claims to have settled the problem.

Caveat: Martin’s productivity estimates and claims about model behavior are personal observations, not measured results from a controlled study.