Carson Gross Reframes Programming Around Complexity Control, Not Code Generation

Simon Willison highlighted an essay by Carson Gross, the creator of the htmx library and an instructor at Montana State University. Gross addresses computer science students asking whether learning to program remains a viable career in an era dominated by generative models. Rather than dismissing AI capabilities, Gross grounds his defense in a strict definition of the craft, which fundamentally rests on 2 essential pillars: solving problems using computers and learning to control the complexity of those solutions.

Synthetic code solves immediate tasks while compounding hidden baggage

Large language models have drastically collapsed the marginal cost of the first pillar, generating syntactically valid code in seconds. However, Gross warns against the trap awaiting junior developers who treat coding agents as an outright replacement for hands-on programming. Developers who bypass writing code gradually forfeit the ability to read, debug, and critically inspect it. Instead of becoming empowered engineers, they become sorcerer apprentices who trigger sprawling workflows they neither understand nor control.

Systemic judgment becomes the primary differentiator for engineering leads

While the mechanical value of typing syntax diminishes, domain comprehension and architectural discipline appreciate significantly. Gross notes that throughout software history, the most destructive software architects were consistently those who lacked foundational coding mileage. Junior developers who delegate basic implementation to bots miss out on developing the visceral intuition required for larger system design. AI functions best as an attentive teaching assistant that clarifies mechanics, rather than an unvetted production generator.

Fast generation easily overwhelms teams with probabilistic technical debt

The operational hazard is not that neural models fail to produce runnable scripts on prompt. The danger arises when probabilistic completions inundate codebases with accidental complexity and redundant scaffolding. Traditional compilers enforce strict deterministic rules, whereas models output plausible token arrangements. Placing an uncritical operator in front of a model does not restore determinism; it merely delegates production liability to humans who must maintain these sprawling modules over the next 10 years.

The discipline to prune unnecessary abstractions will determine product longevity

The defining metric of engineering capability will not be token velocity or daily pull request volume. Organizations that thrive will be those whose engineers aggressively simplify synthetic drafts and discard parasitic abstractions before maintenance costs strangle the roadmap. Engineering organizations that forbid junior developers from writing core code will find themselves stranded within unmaintainable architectures within a few quarters.

Lilith's verdict

Developers who let models write all their code soon end up as clerks inspecting receipts in a language they cannot speak. An engineer real value begins the moment they can slash a generated heap down to five clean functions.