XNews

AI's Impact on Software Engineering: Uncle Bob's Analysis and the 'Dishwasher' Metaphor

AI's Impact on Software Engineering: Uncle Bob's Analysis and the 'Dishwasher' Metaphor

Uncle Bob detailed his AI coding workflow and a 'dishwasher' metaphor illustrated AI's limits. - Uncle Bob initially found AI agents (Grok) left messy code, 'dog feces', and got bogged down by dirty code just like humans. - He shifted from long prompts to deterministic tools: CRAP (complexity/coverage score) and mutation testing, old techniques now feasible with fast, tireless agents. - He built a multi-agent pipeline: Specifier (Gherkin tests), Coder (unit tests & implementation), Cleaner (CRAP analysis), Hardener (mutation testing to 100%), QA Agent (end-to-end scripts). - Single agent task: 5 min; pipeline: ~1 hour; human: ~half day. Quality far exceeds typical human effort. - For architecture, agents built a UML-style visualization tool with a dependency rule file; a checker enforces dependency direction, agents fix violations via dependency inversion, interfaces, or module splits. - He endorses John Ousterhout's 'deep modules' (small interface, deep implementation); models read interfaces and tests to understand systems. - Clean Code adjustments: CRAP threshold raised from 4 to 6 (testing 8); do not impose human discipline like TDD—agents revert to natural style. Core: impose human values, not behavioral discipline. - He opposes heavy upfront planning; experiments with full planning failed. Recommends agile: do a few stories, inspect architecture, manually tidy, repeat. Manual tidying may never be fully automated. - Specifications are temporary; code is the spec. He advises not to download his tools but let agents customize them. - Learning path for new programmers: write code for a year, then be treated like an agent (given agent tasks with deterministic constraints), then run own agents. Read classics (DeMarco, Yourdon, Pragmatic Programmer). Must feel the struggle. - Fundamentals remain essential; Dijkstra's quote on software complexity. Those who ignore fundamentals will hit a wall. Abstraction layers (binary→assembly→compiler→models) repeat the same rules. - A separate analysis used a 'dishwasher' metaphor: a restaurant dishwasher replaces 3 workers, but odd-shaped pots, burnt pans, delicate china still need human washing. Automating the last 5% costs 10x more, so keeping one human is cheaper. - As tools get stronger, total output expands, creating more edge cases; you may fire 3 ordinary dishwashers but hire 2 specialists. AI will eat standard coding, but industry growth will increase boundary cases, system integration, and business understanding gaps that still need humans.

Key insights

AI Agents Produce Messy Code and Get Stuck Without Cleanliness

Uncle Bob's initial experience with AI coding agents like Grok was disappointing: they were fast but left 'dog feces'—messy code, uncleaned dependencies, broken tests. He discovered that agents, like humans, get bogged down by dirty code; once the codebase becomes sufficiently messy, agents fall into a cycle of breaking one thing while fixing another, or simply give up. This observation led him to conclude that code cleanliness is not just a human concern but a critical factor for AI agent effectiveness.

Deterministic Tools Like CRAP and Mutation Testing Replace Long Prompts

Uncle Bob moved away from lengthy prompts filled with TDD and Clean Code rules because models treat them as optional 'guidelines' and suffer from 'lost in the middle' phenomena where mid-context content is ignored. Instead, he adopted deterministic toolchains: CRAP (a score combining cyclomatic complexity and test coverage) and mutation testing (flipping operators to check if tests catch the change). These techniques, which he attempted in 2000 but found too costly for manual repair, are now viable because agents are fast and indifferent to drudgery.

A Multi-Agent Pipeline with Single-Task Agents Outperforms Single Agents

Uncle Bob constructed a relay chain of agents, each handling one task to control context window size: Specifier converts human docs to Gherkin acceptance tests and QA programs; Coder writes unit tests and implementation; Cleaner runs CRAP analysis to clean up messes; Hardener runs mutation testing relentlessly for 100% coverage; QA Agent turns QA docs into executable end-to-end scripts. A single agent completes a task in 5 minutes, the pipeline takes about 1 hour, and a human needs roughly half a day. The pipeline's quality far exceeds what humans typically invest.

Architecture Enforcement via Dependency Rules and Deep Modules

Uncle Bob had agents build an architecture visualization tool (UML-style, drill-down to code) and used a dependency rule specification file to constrain module dependency directions. A checker enforces these rules at the end; violations are fixed by agents through dependency inversion, interface insertion, or module splitting. He endorses John Ousterhout's 'deep modules' concept (small interface, deep implementation), noting that models can read interfaces without reading implementations, and they understand system behavior by reading tests. Any practice that improves code structure helps models comprehend code.

Clean Code Principles Adjusted: Higher Complexity Thresholds, No Human Discipline Imposed

Uncle Bob adjusted Clean Code thresholds for AI agents because their vast, precise short-term memory can handle higher complexity. He raised the CRAP threshold from 4 (for humans) to 6, and is testing 8. He argues against imposing human behavioral discipline like TDD on agents; forcing them to write one test line then one implementation line causes them to revert to their natural style. The core principle: impose human values on agents, but not human behavioral discipline.

Heavy Upfront Planning Fails; Agile, Iterative Development with Manual Tidying Remains Necessary

Uncle Bob experimented with planning everything upfront before handing off to agents, and it was a disaster—plans were always incomplete, agents couldn't fill gaps, and humans had to constantly stop, revise, and restart. He advocates returning to agile: do one or two stories, inspect the architecture, manually tidy, then repeat. He believes that manual tidying step may never be fully automated. Specifications are temporary and ever-changing; the final code is the specification. He even advises others not to download his tools but to have agents customize them.

New Programmers Must Learn Strategic Programming by First Writing Code and Feeling the Struggle

Uncle Bob distinguishes tactical programming (frontline coding, where AI excels) from strategic programming (command-level design, where AI is poor). Since AI has consumed tactical work, new programmers must first write code for a year to understand what agents are dealing with. Then they should be treated like agents—given the same tasks and constrained by the same deterministic tools—for months of low productivity but high learning. Only after passing through this pipeline can they run their own agents. He recommends reading classics from the 1970s-80s (DeMarco, Yourdon, The Pragmatic Programmer) and insists that one must personally feel the struggle to recognize when an agent is struggling.

Software Fundamentals Remain Essential; Abstraction Layers Repeat the Same Rules

Uncle Bob asserts that software engineering fundamentals are still important, citing Dijkstra's statement that software is the most complex thing humans have attempted. Fundamentals organize complexity into forms that both humans and models can conceive. He warns that those who think fundamentals are obsolete will learn painfully and soon. He draws a vertical analogy: from binary to assembly to compilers to models, each abstraction layer rise prompted fears of destruction, but the same rules and fundamentals persisted. Rules discarded will be picked up again within a year.

The 'Dishwasher' Metaphor: AI Automates Standard Work, Humans Fill the Last 5% and Handle Growth-Driven Edge Cases

A separate analysis compares AI tools to a restaurant dishwasher that replaces three dishwashers, but odd-shaped pots, burnt pans, and delicate china still require human washing. Automating the final 5% would cost ten times more than the first 95%, making it cheaper to keep one human. As tools become stronger, total industry output expands, creating more edge cases; you may fire three ordinary dishwashers but hire two specialists for tough cases. AI will consume massive amounts of standardized programming, but the software industry's scale will explode, and the resulting boundary cases, system integration, and business understanding gaps will still need humans in the short term.

Source posts