Ruby on Rails · Published 2026-09-27

Ruby, Rails, and the future of programming - Matz, DHH & Jeremy Daer

privateReview: unreviewedConfidence: high
rubyrailsaiSpinelcompilerllmtoken-efficiencycompilersagentic-systemssoftware-architecture
Open on YouTube ↗

Summary

Overview

  • Speaker: Matz & DHH with Jeremy Daer
  • Channel: Ruby on Rails
  • Main topic: The future of Ruby, Rails, and software programming in the age of AI
  • Purpose: To explore how AI and new technological paradigms influence the future of Ruby, Rails, and the software development industry as a whole. A panel discussion featuring Matz (Yukihiro Matsumoto), DHH (David Heinemeier Hansson), and Jeremy Daer discussing the evolving role of programmers, software development, the impact and limitations of AI tools like LLMs on coding, and the enduring philosophy of Ruby and Rails.

Topic Map

AI and the Future of Programming

  • Explanation: Discussion on whether AI will replace programmers or change their role from software writers to software makers.
  • Key claims:
    • AI will tell and listen to programmers, but will not change the trajectory of programming fundamentally.
    • Moving from software writer to software maker is a broader perspective with more things to learn and consider.
  • Examples:
    • Transitioning from writing code to orchestrating AI agents.
  • Terminology:
    • AI
    • LLMs
    • agents
    • software maker
  • Why it matters: Redefines developer identity and professional fulfillment in modern engineering.

Ruby, Spinel, and Performance

  • Explanation: Matz discusses working on a new alternative compiler for Ruby called Spinel, which compiles Ruby programs to native binary with significantly less memory usage.
  • Key claims:
    • Spinel compiles Ruby programs into native binary and runs significantly faster with reduced memory consumption.
  • Examples:
    • Real-world programs running in 1/20th of memory using Spinel.
  • Terminology:
    • Spinel
    • compiler
    • native binary
  • Why it matters: Demonstrates continuous evolution and performance improvements within the Ruby ecosystem.

The Myth of AI Perfection and Code Generation

  • Explanation: DHH argues against the illusion that AI tools must be completely fault-free or that they replace the need for human judgment and taste.
  • Key claims:
    • AI is an incredible tool that scales productivity, but expecting zero faults out of the box is AI psychosis.
    • Humans must exercise good judgment and review AI outputs just as they would with human code.
  • Examples:
    • Comparing software safety concerns to autonomous driving vehicle safety expectations.
  • Terminology:
    • meat proxy
    • AI psychosis
    • slop grenade
  • Why it matters: Encourages a realistic, pragmatic adoption of AI tools without falling for overhyped fears.

Key Points

Shift from Software Writer to Software Maker

  • Explanation: The identity of developers is shifting from hand-crafting individual lines of code to orchestrating systems and ideas.
  • Evidence: DHH's keynote reflection on developer identity.
  • Practical implication: Engineers should embrace higher-level problem solving rather than fixating solely on syntax.

AI Token Efficiency and Language Design

  • Explanation: Different programming languages have varying token efficiencies and expressive capabilities for LLMs.
  • Evidence: Matz's research into token efficiency across multiple programming languages.
  • Practical implication: Language expressiveness remains vital for human and AI collaboration alike.

Frameworks, Models & Processes

Software Maker Perspective

  • How it works: Broader view of software development focusing on product creation, taste, proportion, and beauty rather than mere code production.
  • Components:
    • Taste
    • Proportion
    • Beauty
    • Abstraction
  • When to use: When adapting to productivity tools and AI assistance in engineering.

Examples & Case Studies

Chad Fowler's benchmark testing various programming languages for token and time efficiency.

  • Illustrates: Ruby, Python, and JavaScript rank high in token efficiency and time efficiency.
  • Lesson: Human-friendly expressive languages are also effective for AI agents.

Actionable Takeaways

  • Immediate:
    • Embrace AI tools as helpful assistants rather than fearing replacement.
    • Focus on human taste, judgment, and problem definition.
  • Strategic:
    • Ruby continues to evolve with performance enhancements like Spinel.
    • Expect tool chains to shift toward high-level agent interaction.
  • Questions to investigate:
    • How will AI-generated code affect long-term code maintainability?
    • What new abstractions will replace traditional libraries and frameworks?

Claims Worth Verifying

  • Spinel compiles Ruby programs into native binary using 1/20th of memory. (technical)
  • Ruby ranks among the top languages in token and time efficiency benchmarks. (empirical)

Notable Quotes

"What we're dealing net with now is not certainty, but probabilities." (at 3:32) "Ruby is a nice language, and favorite language of many people." (at 32:10)

Compressed Summary

  • AI transforms developers from code writers to system orchestrators.
  • Matz introduces Spinel, an experimental native compiler for Ruby.
  • Human taste, proportion, and judgment remain irreplaceable.
  • Ruby's expressiveness makes it well-suited for both humans and AI.
  • Keywords: ruby, rails, ai, spinel, compiler
  • Core insight: AI accelerates software creation, but human taste, judgment, and expressive programming languages like Ruby remain essential for guiding the future of software development.

Core insights

5
Empirical Resultmedium noveltymoderate evidence

Programming languages differ in token efficiency for LLMs, and human-expressiveness correlates with better token and time efficiency in benchmarks.

Why it matters

Token efficiency directly affects LLM context cost, latency, and agent code-generation performance, making language/DSL choice a concrete agent-engineering lever.

Generalization

When building agentic systems that generate or manipulate code, choose languages and DSLs optimized for token efficiency, not only runtime performance.

Ruby, Python, and JavaScript rank high in token efficiency and time efficiency.
Open source video
Human-friendly expressive languages are also effective for AI agents.
Open source video
Empirical Resulthigh noveltymoderate evidence

Spinel, an alternative compiler for Ruby, compiles Ruby programs to a native binary and reportedly runs real-world programs in roughly 1/20th of the memory.

Why it matters

Lower memory footprint for dynamic-language runtimes can reduce the cost and resource requirements of sandboxed execution, batch jobs, and agent-generated code.

Generalization

Alternative compilers/runtimes that trade interpretation overhead for native binaries can make dynamic languages viable in constrained execution environments.

Spinel compiles Ruby programs into native binary and runs significantly faster with reduced memory consumption.
Open source video
Real-world programs running in 1/20th of memory using Spinel.
Open source video
Failure Modelow noveltyweak evidence

Expecting AI code generation to be fault-free out of the box is framed as 'AI psychosis'; human judgment and review remain necessary.

Why it matters

Teams that assume zero-fault AI outputs will under-invest in verification, review, and fallback paths, creating reliability and safety risks.

Generalization

Any probabilistic generative system requires human-in-the-loop review proportional to risk, rather than assuming correctness by default.

AI is an incredible tool that scales productivity, but expecting zero faults out of the box is AI psychosis.
Open source video
Humans must exercise good judgment and review AI outputs just as they would with human code.
Open source video
Predictionmedium noveltyweak evidence

Toolchains are expected to shift toward high-level agent interaction, with new abstractions potentially replacing traditional libraries and frameworks.

Why it matters

This indicates where architecture investment may move: from library/framework APIs toward agent orchestration and higher-level interaction layers.

Generalization

As LLMs mediate tool use, abstractions may consolidate around agent workflows rather than traditional code libraries.

Expect tool chains to shift toward high-level agent interaction.
Open source video
What new abstractions will replace traditional libraries and frameworks?
Open source video
Mental Modellow noveltyweak evidence

AI will change the programmer's role from software writer to software maker, a broader perspective emphasizing taste, proportion, beauty, and abstraction over line-by-line code production.

Why it matters

It reframes developer value toward system orchestration and judgment, affecting how teams train, hire, and design tooling.

Generalization

As generative tools handle more code production, human differentiation shifts toward problem definition, system-level taste, and orchestration.

Moving from software writer to software maker is a broader perspective with more things to learn and consider.
Open source video
AI will tell and listen to programmers, but will not change the trajectory of programming fundamentally.
Open source video

Deep dives

5

Token efficiency as a language-selection criterion for LLM code generation

Research question

Do token-efficiency rankings across programming languages predict real-world LLM code-generation cost, latency, and correctness, and are the effects stable across model families and task types?

Why

Language and DSL choice directly affects agent context cost, latency, and output quality, making token efficiency an engineering lever rather than an aesthetic preference.

Different programming languages have varying token efficiencies and expressive capabilities for LLMs.
Open source video
Matz's research into token efficiency across multiple programming languages.
Open source video
Source video

Spinel native compilation for dynamic-language memory reduction

Research question

Does Spinel preserve Ruby semantics and gem compatibility while delivering the reported 1/20th memory footprint, and what latency or ecosystem tradeoffs appear on representative workloads?

Why

If validated, native compilation can make dynamic languages cheaper to sandbox and run at high density, affecting agent-generated code execution and platform architecture.

Spinel compiles Ruby programs into native binary and runs significantly faster with reduced memory consumption.
Open source video
Real-world programs running in 1/20th of memory using Spinel.
Open source video
Source video

Risk-proportional human review for AI-generated code

Research question

What verification architecture and review thresholds minimize escaped defects from probabilistic code generation without erasing its productivity gains?

Why

Assuming fault-free AI outputs under-invests in review; treating outputs as drafts requires concrete gates, observability, and fallback paths.

AI is an incredible tool that scales productivity, but expecting zero faults out of the box is AI psychosis.
Open source video
Humans must exercise good judgment and review AI outputs just as they would with human code.
Open source video
Source video

Agent-native abstractions versus traditional libraries and frameworks

Research question

As LLMs mediate tool use, what new abstraction boundaries emerge, and do they improve multi-step task success or token efficiency relative to library/framework APIs?

Why

Architecture investment may shift from library/framework APIs toward agent orchestration layers, changing how systems are composed and evaluated.

Expect tool chains to shift toward high-level agent interaction.
Open source video
What new abstractions will replace traditional libraries and frameworks?
Open source video
Source video

From software writer to software maker: measuring and training orchestration skill

Research question

How do teams define, teach, and measure software-maker skills such as taste, proportion, abstraction, and agent orchestration?

Why

If human value shifts to problem definition and system-level judgment, hiring, training, and tooling must change accordingly.

Moving from software writer to software maker is a broader perspective with more things to learn and consider.
Open source video
AI will tell and listen to programmers, but will not change the trajectory of programming fundamentally.
Open source video
Source video

Article ideas

4

Token Efficiency Is Now a Language-Design Constraint for Agentic Systems

Token efficiency across programming languages is not a curiosity but a first-class engineering constraint: it affects LLM context cost, latency, and correctness, so teams building agentic code generation should benchmark and select languages and DSLs accordingly.

Angle

Engineering economics and language design for AI agents.

Source video

AI Psychosis and the Verification Budget: Human Review Should Scale With Risk, Not Faith

Expecting zero defects from AI code generation is a failure mode; teams should treat AI outputs as draft artifacts and allocate verification effort proportional to risk, with automated checks and human review where consequences are high.

Angle

Reliability engineering for probabilistic systems.

Source video

Spinel and the Case for Native Compilation of Dynamic Languages in Agent Sandboxes

Native binary compilation of dynamic languages like Ruby can reduce memory footprint by orders of magnitude, making them viable in dense or constrained execution environments, but semantics, gem compatibility, and latency must be proven before production use.

Angle

Runtime engineering and sandbox economics.

Source video

From Writer to Maker: What Agent Orchestration Does to Developer Identity and Hiring

As generative tools absorb more code production, human differentiation moves to problem definition, taste, and orchestration; hiring and training must therefore measure system-level judgment rather than syntax fluency alone.

Angle

Developer identity, team design, and skills.

Source video

Project ideas

4

TokenEfficiencyBench

beyond-evals

Across identical coding tasks, expressive languages reduce total LLM tokens and wall-clock time compared with more verbose languages, and this reduction predicts lower cost without reducing correctness.

Proof of concept

Build a harness that presents the same suite of coding tasks to multiple LLMs across 5+ languages, recording prompt+completion tokens, latency, cost, and test pass rate.

Measurement

Median token count, wall-clock time, API cost, and correctness delta per language; regression controlling for model family and training-data volume.

Source video

SpinelSandboxCompatibilityHarness

new

Spinel-compiled Ruby binaries preserve Ruby semantics and common gem compatibility for representative applications while using substantially less memory than MRI, with acceptable latency.

Proof of concept

Compile a suite of Ruby programs and a representative Rails-like workload with Spinel and MRI, then run semantic test suites while measuring RSS, latency, and gem loading.

Measurement

Memory ratio, latency ratio, semantic test pass rate, and count of compatible gems.

Source video

RiskProportionalReviewGate

gatehouse

A verification gate that combines automated checks with risk-proportional human review reduces escaped defects from AI-generated code compared with trust-by-default, without eliminating productivity gains.

Proof of concept

Instrument a code-generation pipeline with static checks, tests, sampling-based human review, and severity thresholds; run an A/B test against a trust-by-default workflow.

Measurement

Escaped defect rate, human review time overhead, cycle time, and developer trust scores.

Source video

AgentNativeAbstractionComparator

movement-lab

For multi-step coding tasks, agent-native orchestration abstractions outperform traditional library/framework APIs on task success and token cost, while reducing human intervention.

Proof of concept

Implement the same multi-step task using traditional library APIs and an agent-orchestration abstraction; compare outcomes across repeated trials.

Measurement

Task success rate, total tokens, latency, and human intervention rate.

Source video

Architectural implications

4

Token efficiency varies across programming languages and affects LLM-mediated code tasks.

Before

Language choice optimized primarily for runtime performance, ecosystem, and developer familiarity.

After

Language or DSL choice also considers token efficiency for LLM context, cost, and generation quality.

Consequence

New selection criteria and potentially token-optimized DSLs for agent-facing code generation.

Source video

Spinel compiles Ruby to native binary with dramatically lower memory use.

Before

Dynamic language runtimes often rely on VMs/interpreters with higher memory overhead.

After

Native binary compilation can reduce memory footprint by orders of magnitude for some workloads.

Consequence

Cheaper sandboxing and execution of dynamic-language code in constrained or high-density environments.

Source video

Developer identity shifts from software writer to software maker orchestrating agents and systems.

Before

Primary work is hand-crafting individual lines of code.

After

Primary work is orchestrating agents, tools, and system-level design with taste and judgment.

Consequence

New abstraction layers needed for orchestration, review, and high-level intent capture.

Source video

AI outputs are probabilistic and not fault-free by default.

Before

Assume generated code or outputs are correct unless proven otherwise.

After

Treat AI outputs as draft artifacts requiring verification and human review.

Consequence

Architectures must include verification steps, observability, and human-in-the-loop controls.

Source video

Tradeoffs and failure modes

3

AI productivity vs overexpectation

Benefit

AI scales productivity and acts as an incredible tool.

Cost or risk

Expecting zero faults out of the box leads to 'AI psychosis' and misplaced trust.

AI is an incredible tool that scales productivity, but expecting zero faults out of the box is AI psychosis.
Open source video
Source video

AI-generated code speed vs maintainability

Benefit

AI accelerates code creation.

Cost or risk

Long-term maintainability of AI-generated code is unknown.

How will AI-generated code affect long-term code maintainability?
Open source video
Source video

High-level agent toolchains vs traditional abstractions

Benefit

Toolchains shift toward high-level agent interaction and higher-level orchestration.

Cost or risk

Traditional libraries and frameworks may be replaced by unfamiliar abstractions, creating uncertainty and migration risk.

What new abstractions will replace traditional libraries and frameworks?
Open source video
Source video

Open questions

5

How will AI-generated code affect long-term code maintainability?

Why unresolved

The summary raises the question but provides no evidence or answer.

Research direction

Longitudinal studies measuring maintainability, defect rates, and refactoring costs of AI-generated versus human-written code.

Source video

What new abstractions will replace traditional libraries and frameworks?

Why unresolved

The summary poses this as an open question without concrete proposals.

Research direction

Design and prototype agent-native abstractions, then compare them to existing library/framework boundaries.

Source video

How well do token-efficiency benchmarks translate to real-world LLM code generation cost, latency, and correctness?

Why unresolved

The summary cites a benchmark but no detailed methodology or outcome data.

Research direction

Controlled experiments across languages measuring tokens, time, cost, and correctness for identical tasks.

Source video

Does Spinel preserve Ruby semantics and ecosystem compatibility, and what are its performance tradeoffs?

Why unresolved

The summary reports only a memory advantage without compatibility or latency details.

Research direction

Benchmark Spinel on representative Ruby applications, testing semantics, memory, latency, and gem compatibility.

Source video

Will AI fundamentally change the trajectory of programming or only the tooling and developer role?

Why unresolved

The summary contains a prediction that the trajectory will not change fundamentally, but this is contestable.

Research direction

Track developer workflows, toolchain evolution, and abstraction changes over time to test the prediction.

Source video

Key claims

7
comparativeVerification needed

Spinel compiles Ruby programs into native binary using 1/20th of memory.

Evidence

Real-world programs running in 1/20th of memory using Spinel.

Question

What benchmarks and workloads support the 1/20th memory claim, and how does Spinel compare on latency and compatibility?

Source video
comparativeVerification needed

Ruby ranks among the top languages in token and time efficiency benchmarks.

Evidence

Ruby, Python, and JavaScript rank high in token efficiency and time efficiency.

Question

What was Chad Fowler's benchmark methodology, and do the results generalize across model families and tasks?

Source video
causalVerification needed

Human-friendly expressive languages are also effective for AI agents.

Evidence

Human-friendly expressive languages are also effective for AI agents.

Question

Does expressiveness causally improve agent performance, or is the correlation confounded by training data volume?

Source video
predictionVerification needed

AI will tell and listen to programmers, but will not change the trajectory of programming fundamentally.

Evidence

AI will tell and listen to programmers, but will not change the trajectory of programming fundamentally.

Question

What evidence would falsify the prediction that AI does not fundamentally change programming?

Source video
opinionVerification not requested

Expecting zero faults out of the box from AI is AI psychosis.

Evidence

expecting zero faults out of the box is AI psychosis.

Source video
predictionVerification needed

Tool chains will shift toward high-level agent interaction.

Evidence

Expect tool chains to shift toward high-level agent interaction.

Question

What observable changes in tooling and workflows would confirm a shift toward high-level agent interaction?

Source video
opinionVerification not requested

Moving from software writer to software maker is a broader perspective with more things to learn and consider.

Evidence

Moving from software writer to software maker is a broader perspective with more things to learn and consider.

Source video

Connections

5