Andrey Ashgaliyev

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.

IdeaUpdated November 13, 20261 source2 min read

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:

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

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

People & organisations

Sources

  1. Jonathan Blow — Based Academy interview on software, AI and Jai