Phillip Mortimer argues AI-generated code is write-only, disposable, and too dense for human review at scale

Mortimer's core claim is that AI-generated code shares the characteristics of historically dense languages like APL and regular expressions: it trades readability for power. Under that framing, the code itself is no longer the artifact you maintain; the tests are. Engineers read input-output pairs to understand behavior because the implementation is too dense to parse directly. This inverts the usual relationship between code and tests, making the test suite the contract and the code a disposable implementation detail.

The disposable-code principle has a direct operational consequence: when something breaks, you keep the tests and regenerate the code rather than debugging it. Mortimer explicitly states that write-only code is so hard to debug that rewriting is often cheaper. This shifts maintenance cost from comprehension and patching to regeneration and re-verification, which only works if the test suite is comprehensive enough to catch regressions. Where tests are thin, the model offers no safety net, and the approach stops working.

Mortimer identifies human code review as a scaling bottleneck and proposes automating it through CI-invoked coding agents that apply review skills. He acknowledges the apparent paradox of a model reviewing its own output but reports that a different prompt, context, and instruction set can produce meaningful adversarial review. This suggests a practical pattern: separate agent roles for generation and review, each with distinct instructions, rather than relying on a single pass. The approach is becoming common in agentic systems beyond code review, according to Mortimer.

The self-healing proposal extends the automation further: an AI coding agent monitors an observability platform, aggregates alerts over a time window, and raises pull requests to fix the most common problems first. This moves the agent from a build-time tool to a runtime operator that reacts to production signals. The cost of adopting this is non-trivial: it requires a mature observability stack, confidence that automated fixes will not introduce new failures, and a CI pipeline that can accept agent-generated PRs. Mortimer does not detail where this breaks down, but the approach clearly depends on the quality of the alerting and the reliability of the fix agent.

Mortimer frames the broader shift as a decoupling of intent from implementation, with natural language making developers portable across programming languages. He positions creativity as the remaining human role, arguing that AI has solved the implementation problem. This is a strong claim with limited corroboration: only one feed carried this talk, and the argument rests on Mortimer's experience rather than measured outcomes. Engineers evaluating this thesis should note that the practices he recommends, exhaustive tests, automated review, observability-driven healing, are concrete and testable, while the claim that implementation is fully solved is an assertion that the material does not substantiate.