Wiki › Engineering with agents
Software Complexity and Global Invariants
Why local code generation differs from preserving whole-system correctness, with Blow’s critique of complexity, platform incentives and AI coding.
Software complexity is not merely a count of lines or abstractions: it includes the interacting constraints that a change must preserve across the system. In Jonathan Blow’s interview, the central distinction is between generating a locally plausible function and changing a large program without violating its global invariants.
Local output versus system correctness
At 49:43–53:28, Blow gives two concrete examples:
- An acceleration structure must remain synchronized with its underlying data.
- During an update, certain operations must not run against a temporarily inconsistent structure, whether on another thread or within the same execution flow.
As design decisions accumulate, so do obligations on future changes. The bottleneck is understanding and preserving these obligations, not simply an editor’s or compiler’s ability to process more lines. Blow’s numerical examples of very large games are illustrative testimony, not a measured universal size limit.
Where AI assistance fits
At 43:44–48:25, Blow describes relatively self-contained “leaf” work: generating variants of a function with explicit inputs and behavior. He reports using AI for roughly 30–40 lines of Visual Basic to format an Excel sheet for voice-acting work, outside the game’s core code. It was useful but had unhandled corner cases. This is a boundary example for AI-Assisted Software Development, not a claim that he never uses AI.
He is much less willing to delegate tightly coupled gameplay logic whose defects could make puzzles exploitable. His critique of LLM reasoning and his anecdote about sales forecasts following his suggestions should be read as reasons for skepticism, not controlled evidence that future models cannot preserve invariants (53:28–59:09).
Where avoidable complexity comes from
Blow attributes some complexity to weak engineering discipline and some to commercial platform incentives. His team’s cross-platform shader language illustrates the integration work shifted onto developers by different backend languages and APIs (13:47–23:15). Claims about vendor motives are his interpretation, not an independently verified explanation of every incompatibility.
At 33:07–39:30, he presents Jai as an alternative systems-language design direction. His proposed test for new tools is to compare realized benefits with promised benefits and added complexity, while avoiding reflexive rejection of innovation.
Connection to existing arguments
- Loop-Dependent Software describes the maintenance risk when humans can no longer understand a generated system without continuous machine mediation.
- Agentic Software Factories offers a competing control mechanism: executable verification rather than reading every line. The unresolved issue is whether the verification captures the important global constraints.
- DRY Principle warns that superficially similar code is not necessarily shared knowledge; eliminating lines can add hidden coupling rather than reduce semantic complexity.
Practical synthesis and open question
A useful engineering response is to keep delegated changes bounded, make cross-component invariants explicit, verify transitions as well as happy-path outputs, and evaluate total integration and maintenance cost rather than generation speed alone. This is a synthesis with the related pages, not a verbatim checklist from the interview.
Can models plus a verification harness maintain these constraints more reliably than a human-centered workflow, and for which systems? The interview raises the question but does not settle it.
Mentioned in 5 pages
Engineering with agents
- AI-Assisted Software Development
- Agent Verification Loops
- Agentic Software Factories
- Loop-Dependent Software
People & organisations