Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Code Matters: Reflections on Rust in the LLM Age

Avatar for Bryan Cantrill Bryan Cantrill
October 22, 2026
16

Code Matters: Reflections on Rust in the LLM Age

Talk given at the Rust NYC meetup on October 22, 2026. Video: https://www.youtube.com/watch?v=5D7QPOIZ7gY

Avatar for Bryan Cantrill

Bryan Cantrill

October 22, 2026

More Decks by Bryan Cantrill

Transcript

  1. Before Rust • Throughout the 1990s and 2000s, programming language

    emphasis was on making the construction and agglomeration of software easy • Ease of construction was enshrined over its operation: developer time was quantifiable and precious; operational toil was hidden and implicit! • This resulted in constructs with lower cognitive load in development – but implicitly in exchange for emergent behavior in production • Examples abound: dynamic typing, M:N threading, garbage collection, exceptions, ORM, RPC OXIDE
  2. Abstraction • The essence of software systems is the creation

    of abstraction • Abstractions allow us to build software systems that do sophisticated things; they are the shoulders we stand upon – and provide to others • Abstractions are qualitative; good ones allow us to hide gory implementation details – to build castles atop them and tunnels beneath • Bad ones, however, leak: instead of sealing implementation details, they seep them – yielding systems that are unwieldy and brittle • Emergent behaviors in production constitute leaky abstractions! OXIDE
  3. Abstraction and complexity • When abstractions leak, are absent, or

    became unnecessarily entangled with one another, we have complexity • Fred Brooks famously called this accidental complexity, differentiating it from the essential complexity endemic to a particular problem • Complexity doesn’t merely accrue, however – it can explode… • Uncontained accidental complexity in one component can become essential complexity in something that must interact with it! OXIDE
  4. The Revolutionary’s Paradox • Programming languages are revolutionary by nature

    – they are often a reaction to the complexity that has come before them • However, because programming language revolutions emphasized ease of development at the expense of production artifacts, they not only induced emergent complexity, they accelerated it • They became a speed run to accreted systems – often becoming the complexity that they had once sought to overthrow • Fortunately, a deeper revolution was fomenting… OXIDE
  5. The Rust Revolution • With its focus on infrastructure, Rust

    optimized for the artifact first – and then within the confines of those constraints, the developer experience • This shifts cognitive load to the developer in development – but the bounty of the bargain is in safety, security, robustness, etc. • For those for whom the artifact was always the constraint, Rust brings modernity: we can have nice things! • Cognitive load was so shifted as to yield a novel experience for infrastructure software: Rust that compiles very often just works! OXIDE
  6. The Rust Revolution meets LLMs • Rust’s putative weakness –

    its steep learning curve – is in fact a strength for LLMs: compilation provides ample feedback! • Rust’s strong packaging ecosystem yields robust foundation for LLMs • Added to the safety and performance of the artifact, Rust is an especially appealing target for LLM-generated software • Rust has, if anything, become too appealing a target… OXIDE
  7. The peril of LLMs: Laziness lost • Aside from the

    obvious perils to generating code that one cannot read, there is a deeper peril with respect to the generation of abstraction… • Simple, powerful abstractions stem from a human limitation: our need to comprehend and compose systems • This is our drive to cognitive efficiency in a system – what Larry Wall famously called the programmer virtue of laziness • LLMs lack the virtue of laziness – they are biased to the complex! OXIDE
  8. The peril of LLMs: Management consultancy effect • Worse than

    merely lacking laziness, LLMs are incentivized to work – it is reasonable to presume that these incentives become perverse! • This leads to an LLM-variant of the management consultancy effect, which breeds dependency rather than completion • Left to their own agency, LLMs will – implicitly or explicitly – insist on work in lieu of abstraction; they cannot become the revolutions that they have benefited from! OXIDE
  9. The peril of LLMs: Gas Town as cautionary tale Steve

    Yegge, The Shape of Things to Come (August, 2026) OXIDE
  10. Rust in the LLM age • LLMs are extraordinarily powerful

    – but they are a tool • With respect to Rust, LLMs are particularly enticing – but their efficacy is because of Rust’s dedication to robust abstractions! • Such as we use LLMs, they should be to enhance and inform our human ability to create abstractions – not to supplant it • Newcomers to Rust should learn Rust • Remember that Rust remains a tool for building other infrastructure – and the code very much still matters! OXIDE
  11. Further reading and listening • Rich Hickey’s classic 2011 talk,

    Simple Made Easy • Fred Brooks’s timeless 1986 essay, No Silver Bullet – Essence and Accident in Software Engineering • Oxide and Friends, No Silver Bullet and Engineering Rigor in the LLM Age (see also Rain Paharia’s iddqd, or the hardest kind of unsafe Rust) • RFD 576 Using LLMs at Oxide OXIDE