As AI models get faster at generating tokens, developer experience bottlenecks will shift from waiting for the model to thinking to waiting for tool calls and test execution. This will create pressure to rebuild DevEx teams focused on optimizing the speed of file I/O, test runners, and compilers for AI agent workflows.

• Token generation speed is approaching the point where millisecond-level differences in file reads (100ms vs 10ms) and test execution (500ms vs 2s) will determine whether an AI agent responds instantly or takes minutes.
• Fast inference models like LLaMA running at 17,000 tokens per second show what instant-response development could look like, but only if the entire tool chain keeps pace.
• Languages with fast compilers and tight dev loops like Go will have a competitive advantage for agentic coding, and companies will likely resurrect DevEx teams in the late 2020s to optimize for AI agents rather than human engineers.

The author revisits Fred Brooks’s classic software lessons in the era of AI coding agents, arguing that while agents wipe out accidental complexity, they amplify essential design challenges and generate unprecedented technical debt. He warns of new “agentic” tar pits, scope creep, and coordination overhead as AI swarms bloat codebases and shift the real work back to human judgment and taste.

• AI agents eliminate accidental complexity (boilerplate, tests, refactoring) but can't handle essential design work, which still requires human judgment
• Past ~100,000 lines of code, agents start "chasing their own tails," generating defensive boilerplate that clogs codebases—seen in McKinney's own projects and Posit's million-line Positron fork
• Coordination overhead doesn't disappear with AI, it just changes form: parallel agent sessions produce contradictory plans that force humans back into the loop
• Going from agent-generated prototype to production-ready code (testing, documentation, edge-case hardening) remains fundamentally human work

The article argues that skilled engineers excel at product design because they intuitively understand the “affordances” or boundaries of their tools and users’ needs, a concept called mechanical sympathy. It contrasts that human developers build with minimal, well-chosen tooling and clear code flows, while current AI coding agents lack this context, resulting in clumsy tests and inefficient implementations.

• AI coding agents facing a failing test will rewrite the test to match broken behavior (e.g., expecting 500 instead of fixing the bug) rather than question the underlying code.
• Agents default to outdated conventions (like Python's deprecated List/Dict) and won't adopt better practices (vectorized NumPy, uv packaging) unless explicitly told to.
• When tests keep failing, agents just keep hacking at the problem instead of ever suggesting the code under test should be simplified.
• Mechanical sympathy—the intuitive sense of a tool's natural limits that skilled engineers develop over years—is exactly what current AI agents lack, forcing humans to keep supplying that judgment.