DHH — Rails World 2026

Agents write the code. He picked Rust for a mail server he never wants to read. That is not a verdict on Python for the rest of us.

English is a better programming language than Ruby.

— DHH, Rails World 2026

He means the spec — the outcome you give the agent — not that Ruby (or Python) died this afternoon. The scarce skill is stating the work in English. The compiler is now an agent that may emit Rust you never read.

← AI · AI Agents · Tech · Dual-rail · Loops · Named threads

Source

David Heinemeier Hansson (@dhh) — Rails World 2026 opening keynote, Austin (~23 Sep 2026). ~63 min. Official upload: youtube.com/watch?v=vDjW_dRyKXY (Ruby on Rails channel).

His post after the talk: “It’s pencils down, people. Writing code by hand is no longer an economically viable skill for most programmers at most companies.” Don’t black-pill it.

This page is a study file, not a transcript. CPU/memory numbers and the Raspberry Pi line are his claims from the stage — treat as self-report, not a paper.

Clip — coding by hand is gone

Short cut of the “new way” beat: pencils down, agents write, English as the spec. Full keynote is below.

Hosted: static2.mikesblog.com/dhh.mp4

Full keynote

One-sentence TL;DR

37signals treats agent-written code as the default. HEY becomes native apps + a Rust mail core because the bottleneck moved from “who can type Ruby” to “what the metal costs.” Rails is still his answer for web apps. Python stays the answer here for product/GTM glue you actually QC.

What he argued (points)

Kodak Brownie of agents. He dates a phase change (he’s used ~24 Nov 2025 in surrounding posts): frontier models cheap enough that “everyone gets a camera.” Painting analogy up front — then the match.
Pencils down. At 37signals, writing code by hand is now an exceptional state — like seeing a bug in Sentry. If you have to type, fix the agent setup, don’t make typing the job. He asked the room who still writes material amounts by hand each week; about five hands.
English over Ruby (for directing work). The pull quote above. Scarce skill = stating the outcome. Not a funeral for Ruby (or Python).
Volume. He cited on the order of 150k lines in August 2026 vs a long-run ~30k lines of production Ruby per year. Half as much code in ~20 months as in the previous 21 years — because agents. Treat the counts as his diary, not a benchmark you must hit.
The 1,000× gap (his framing): worst programmer with no agents vs best with agents. Old 10× debate is small next to that. Maps to /dualrail: you orchestrate; you are not the compiler.
HEY is not a web app anymore. Rebuild as six native clients (kicked off about a week before the talk). Native was expensive when humans typed every platform; agents collapse that cost. He pointed at Shopify’s Shop app going native with a small team as the same idea.
Backend: Rust, and he still hates reading it. “Pouring acid in my eyes.” Division of labor: agents like Rust; he never has to look; outcomes are small, safe, fast binaries. The thing they’re rewriting is the mail server at the core, not a CRUD admin.
Efficiency claims (self-report): ~99% less CPU, ~95% less memory vs the old stack; ~10 hosts kept for redundancy; napkin math that peak HEY traffic might fit on a Raspberry Pi. That is the “straight to the metal” pitch — portable, not a cluster of Ruby processes rendering HTML.
Where that leaves Rails. For HEY: native + Rust. For the web (ephemeral users who won’t install): he still argues Rails’ convention-over-configuration is token-efficient for agents. Do not quote this keynote as “DHH killed Rails.” He killed HEY-as-a-Rails-HTML-app.
Abstractions were for human keystrokes. DRY, clever base classes, “one true helper” — those existed because repeating code was expensive. Agents make repetition cheap; a shared layer every agent must edit becomes a choke point. Explained below. He is not saying throw away Rails conventions (those help agents). He is saying stop building extra architecture just to save typing.
Optimism, not a funeral. Omarchy (his Linux desktop), tiny agent-built binaries (he mentioned a Markdown presentation tool as a half-megabyte binary). Don’t black-pill the moment.

What “abstractions” means here (plain English)

In programming, an abstraction is a layer you invent so a human does not have to look at the messy details twice. You hide HTTP behind Rails. You hide SQL behind an ORM. You extract a shared function so you Don’t Repeat Yourself (DRY). Frameworks, design patterns, base classes, “service objects,” a company-wide utils package — all abstractions.

They were a bargain when you typed. Copy-pasting the same 40 lines into six files was stupid. One clever module was cheaper to write and cheaper to read.

DHH’s claim (around the “rethink the craft” stretch of the talk): that bargain flipped.

	Human-typed era	Agent-typed era (his bet)
Repetition	Expensive. You pay in hours and bugs.	Almost free. The agent will write the 40 lines again.
Shared clever layer	Saves keystrokes. One place to fix.	Choke point. Six agents all have to understand it, not break it, and wait on it.
DRY / “one true helper”	Good taste.	Can become a bottleneck. Duplication is now the cheap kind of mess.
What still helps	Convention you can remember.	Convention an agent can predict (Rails-style). Not a unique snowflake architecture.

Concrete picture. Old you: “We have three ways to send email — extract MailerService.” New you (his version): “Tell the agent ‘send this email’ in each place. Don’t make a cathedral of indirection that every future agent has to climb.” If the send logic changes, you re-prompt. You do not maintain a sacred shared class that only you understand.

Two things he is not saying, mashed together in recaps:

Not “delete Rails / Django / FastAPI.” Those are predictable conventions. Agents spend fewer tokens when the project looks like a thousand other projects. That is why he still praises convention over configuration.
Not “never share any code.” A tiny, boring helper is fine. The target is architecture built to save human typing — extra layers, premature frameworks, DRY for its own sake.

On this desk: keep FastAPI because you can QC it (/dualrail). Don’t invent a new internal framework so you “won’t repeat yourself” across agent threads. Repeat the English spec. Let the agent repeat the code.

Skepticism (keep this next to the clip)

99% / 95% / Pi are his measurements and envelopes on a rewrite in flight. Copy the direction (hot path belongs near the metal), not the percentages onto your CRM.
Pencils down is a 37signals SOP. If the agent is wrong, someone still has to read the diff. “Never look at Rust” is a dare, not a safety policy — see /gymhack.
Native × 6 is cheap for them because agents + a mail product with a real install base. A GTM FastAPI is not HEY.
“No more abstractions” is easy to over-read. Shared modules still pay when one bug must be fixed once (auth, billing, a deny list). Don’t duplicate the gym-hack surface in six files because DHH said DRY is old. Duplicate the boring glue; keep one fence for send/spend/publish.

Python vs Rust (because you actually use Python)

DHH’s move is Ruby/Rails → Rust for a mail core. The question on this desk is Python vs Rust. Same split: language you QC vs language the compiler QC’s.

	Python (this desk)	Rust (HEY’s new core)
What it is	Interpreted (CPython), garbage collected	Compiled to native code, no GC — ownership / borrow checker
How you think	“Do the thing.” dicts, FastAPI, a script this afternoon	“Who owns this memory?” Types are the program
Speed / RAM	Fine until a hot loop or a million connections	Often an order of magnitude less CPU/RAM on the same loop; one small binary
Day-1 app	Today	Slow if you type it; DHH’s bet is agents type it
Ecosystem	Agents, GTM glue, CRM, scraping, LLM calls — Python’s house	Servers, parsers, CLIs, WASM. Fewer “import pandas” moments
Failure mode	Runtime: `None`, wrong type, one request kills the worker	Mostly won’t compile. Once it runs, fewer foot-guns
You reading it	You will, and that’s the point of dual-rail QC	DHH’s pitch: never. Only steal that if you have another QC (tests, compiler, review you trust)

Keep Python when the bottleneck is directing agents, not the CPU: FastAPI, Bernie, BirthdayView-class APIs, scripts, dual-rail review. You share a language with the agent.

Let an agent write Rust (a sidecar, not a religion) when a profiler says Python is the bill: parse, crypto, queue, fan-in, a static binary on the VPS with no venv. Same as DHH: metal where metal matters; high-level where the product still lives.

Do not rewrite the GTM stack because a keynote at a Rails conference picked Rust for email.

How this maps here

His move	Here
Pencils down / agent default	/dualrail — you QC both rails; you don’t fill silence by typing a fourth app
Named outcomes, not typing	/grokthreads · /loops
Rust mail core on few boxes	/aiagentvps is still Linux + whatever language; don’t cargo-cult a Pi
Never read the generated Rust	Skip as policy. Read diffs that send, spend, or store keys (gymhack, keychain)

What we keep vs skip

Keep: agents as the default compiler; English as the spec; native when install is the product; Rust (or any systems language) for a measured hot path; Rails/Python/web for people who won’t install.
Verify: those 99%/95%/Pi numbers on a finished HEY; whether agents in your stack write Rust you can still test.
Skip: “Python is dead”; rewriting CRM in Rust this week; pencils-down meaning no review; quoting this as DHH abandoning web apps entirely.

Related on this site

Dual-rail — orchestrate, don’t compile
Loops · named threads
Operator vs engineer
AI agent VPS · super desktop app
Gym hack — unreviewed agent code is still a credential

Primary: Rails World 2026 Opening Keynote — DHH · @dhh