37signals Halts Handwritten Code as DHH Shifts to AI Software Agents

Ruby on Rails

Handwritten programming is no longer economically viable because autonomous agents yield up to 1,000x productivity gains, rendering traditional code abstractions obsolete in favor of natural-language orchestration.

AI-assisted summary of Rails World 2026 Opening Keynote - DHH — original source. Check the original for full context.

Source published: 2026-09-28

Key ideas

• 37signals has formally instituted a 'pencils down' policy on handwritten code, treating manual software authoring as an exceptional failure state comparable to an application error. (20:45)
• HEY is abandoning the web app model to ship six platform-native clients alongside a Rust mail backend generated entirely by AI agents, reducing server CPU usage by 99% and memory by 95%. (24:04)
• DHH identifies November 24, 2025 (the release of Claude Opus 4.5) as software's 'Kodak Brownie' inflection point, marking the moment autonomous agents made manual coding economically obsolete. (11:20)
• DHH announced his personal retirement from handwritten coding after generating 150,000 lines of code in a single month—a 60x leap over his historical multi-decade average. (39:21)

Detailed notes

## Background Published on YouTube by the official Ruby on Rails channel on September 24, 2026, this video documents David Heinemeier Hansson's (DHH) opening keynote at Rails World in Austin. The presentation details why 37signals instituted a formal 'pencils down' policy on handwritten code, how Rails' convention-over-configuration design thrives alongside autonomous agents, and why radical optimism is the only rational response to the AI era.

## TL;DR Drawing a historical parallel between 18th-century portraiture's disruption by the Kodak Brownie and modern programming's inflection point with Claude Opus 4.5, DHH announces his retirement from manual code authoring as 37signals transitions to agentic development. He details radical architectural pivots, including rewriting HEY's backend into agent-authored Rust and generating six native platform apps in a week, while building custom desktop utilities and the Omarchy OS without inspecting underlying implementations. DHH argues that natural English has superseded formal syntax, traditional human-centric DRY abstractions must give way to agent-friendly architectures, and applications must expose CLIs for user-owned agents rather than embedded chatbots. Ultimately, he reframes fears of automation through Jevons' Paradox and game theory, urging developers to reject catastrophic doom-mongering in favor of an unapologetic 'white pill' of total optimism.

## Atmosphere & style Electrifying, provocative, and unapologetically evangelical, the presentation carries the kinetic energy of an ideological revival meeting. DHH paces the stage with unabashed 'AI euphoria,' blending historical art history and geopolitical anecdotes with irreverent, combative developer broadsides against bloated software and reactionary pessimism. The emotional trajectory begins by acknowledging the disorienting vertigo of rapid technological disruption, only to rapidly pivot into infectious, breathless empowerment. Watching the keynote feels like receiving an aggressive shot of adrenaline, leaving the audience challenged to discard legacy habits and seize an unprecedented explosion of personal agency.

## Bulletin - [20:45](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1245s) 37signals has formally instituted a 'pencils down' policy on handwritten code, treating manual software authoring as an exceptional failure state comparable to an application error. - [24:04](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1444s) HEY is abandoning the web app model to ship six platform-native clients alongside a Rust mail backend generated entirely by AI agents, reducing server CPU usage by 99% and memory by 95%. - [11:20](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=680s) DHH identifies November 24, 2025 (the release of Claude Opus 4.5) as software's 'Kodak Brownie' inflection point, marking the moment autonomous agents made manual coding economically obsolete. - [39:21](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2361s) DHH announced his personal retirement from handwritten coding after generating 150,000 lines of code in a single month—a 60x leap over his historical multi-decade average.

## Key takeaways - [05:21](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=321s) The Kodak Brownie's democratization of photography mirrors AI's current impact on software: when capturing realism became cheap, painters pivoted toward Cubism and Impressionism rather than disappearing. - [11:20](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=680s) November 24, 2025 (Claude Opus 4.5) established the boundary between legacy manual programming and modern agentic pair development. - [12:43](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=763s) A brief trough of disillusionment in early 2026 was shattered by mid-year frontier releases, rendering debates over scaling-law plateaus obsolete. - [16:02](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=962s) The decades-long debate over the 10x programmer has been eclipsed by top-tier developers wielding agentic tools to achieve 100x to 1,000x productivity multipliers. - [18:13](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1093s) The core spirit of Rails—celebrating convention over configuration and eliminating boilerplate toil—re-emerges fully in the agentic era. - [20:45](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1245s) 37signals adopted an operational 'pencils down' baseline where agents author code by default and manual intervention triggers systemic prompting fixes. - [24:04](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1444s) Near-zero marginal coding costs eliminate historical compromises like hybrid frameworks, enabling lean teams to maintain bespoke native codebases across multiple platforms. - [28:59](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1739s) Low-level languages like Rust, while syntactically grueling for human eyes, become ideal black-box targets for AI agents to achieve extreme runtime efficiency. - [31:46](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1906s) Agentic interaction works best asynchronously: developers assign high-level problems rather than micro-managing tasks through interactive chat boxes. - [33:04](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1984s) Rails remains critical for the web distribution layer, where convention over configuration provides autonomous agents with superior token efficiency and architectural structure. - [38:06](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2286s) English has surpassed traditional programming languages in expressiveness and utility, transforming software engineers from code-chiselers into high-level system orchestrators. - [43:03](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2583s) Traditional DRY abstractions become dangerous concurrency bottlenecks when thousands of autonomous agent processes modify codebases in parallel. - [45:15](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2715s) Applications must prioritize command-line interfaces (CLIs) so personal user agents can drive software headlessly, rather than relying on embedded in-app chatbots. - [53:53](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3233s) Agents enable continuous overnight micro-optimization, reversing two decades of desktop software bloat and yielding blazing, sub-megabyte binaries. - [01:00:08](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3608s) Catastrophic forecasts surrounding automation routinely fail to account for Jevons' Paradox and historical precedents where lower operating costs expanded total opportunity. - [01:00:49](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3649s) Game theory dictates total optimism: despair offers no strategic upside, whereas radical optimism empowers engineers to shape technological abundance.

## Detailed walkthrough ### [00:07](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=7s) Welcome to Austin and AI Euphoria

Welcoming the audience to Rails World in Austin, David Heinemeier Hansson (DHH) quips that while he would normally say "welcome to Austin," he really ought to say "welcome back to myself," having just spent five hours yapping on a podcast in the city only a month earlier. Personal travel aside, DHH expresses profound gratitude simply to be alive right now and sharing this historical juncture with the Ruby on Rails community and anyone electrified by the arrival of software agents. He jokes that if anyone in the audience has not caught the fever yet, they likely will by the end of his "delirious talk on the future."

He acknowledges that when people see someone pacing around on stage buzzing with this level of excitement, their first instinct is often clinical: diagnosing him with "AI psychosis." DHH embraces the sentiment but reclaims the vocabulary, calling his state "AI delirium" or "AI euphoria." In his view, what we are witnessing is simply the most exciting capability humans have ever coaxed out of computers across all his decades of working, playing, and interacting with machines. Yet alongside that excitement sits a legitimate, unnerving tension: nobody knows what the final steady state will look like, and any prediction attempted today is rendered obsolete roughly twenty minutes later. That rapid obsolescence generates an understandable sense of unease, which DHH seeks to soothe by stepping back in time to examine technological precedent.

[01:50](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=110s) The 18th-Century Portrait and the High Friction of Art

To put our current anxiety into perspective, DHH winds the clock back to portrait painting—the state-of-the-art capture technology of the 18th century. In that era, having your likeness preserved required sitting motionless for hours upon hours in front of a master painter, who would then spend months executing the canvas. While this craft yielded a magnificent cultural heritage—such as Joshua Reynolds's 1781 masterwork of the Ladies Waldegrave—it was an immensely exclusive, high-friction endeavor that only the upper bourgeoisie or royalty could afford.

The process was also fraught with client friction. Reynolds had previously poured months into an earlier portrait of the Ladies Waldegrave, only to have the client reject it because an ankle was visible—a scandalous indiscretion that forced him to start over from scratch. DHH sympathizes with Reynolds, noting that anyone who has ever wrestled with clients over rejected statements of work understands the pain. Around this era, technique advanced at a glacial crawl over hundreds of years: twenty years after Reynolds, Francisco Goya painted the Spanish royal family in 1801 with essentially the same manual, painstaking craft. Eighty years later, Danish painter Laurits Tuxen spent not three months, but three full years, painting the Danish royal family in an 1886 canvas that still hangs in Copenhagen's royal palaces today.

```mermaid flowchart TD accTitle: The Shift from Bespoke Portraits to Ubiquitous Photography accDescr: Diagram tracing the historical disruption of portraiture by photography, leading to mobile ubiquity.

subgraph ManualCraft["Manual Craft (Centuries)"] A["1781: Reynolds (Months of sitting)"] --> B["1886: Tuxen (3 years for Danish Royals)"] end

subgraph Disruption["The Democratization Shocks"] C["1840s: Invention of the Camera"] --> D["1900: Kodak Brownie ($1 Mass Access)"] D --> E["Artistic Pivot: Cubism & Impressionism"] end

subgraph Frictionless["Zero Marginal Cost"] F["1925–1980s: Leica & Film (Gradual Growth)"] --> G["2026: Smartphones (2 Trillion Photos/Year)"] end

ManualCraft --> Disruption Disruption --> Frictionless ```

[05:21](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=321s) The Kodak Brownie and the Great Creative Pivot

By the late 19th century, manual portraiture had reached the end of its reign. The camera had arrived around 1840, steadily improving until the Eastman Kodak Company unveiled the Brownie in 1900. By dropping the cost of a picture to about a single dollar, the Brownie mass-produced photography and democratized image-making. Master painters suddenly faced direct technological competition: when an optical device could capture reality faster and cheaper, meticulously depicting objective reality ceased to be an economically viable craft.

Rather than vanishing, artists pivoted. Deprived of their monopoly on realism, painters exploded into new creative territory: Pablo Picasso pursued Cubism, while the Danish Skagen painters turned toward Impressionism. This artistic pivot holds a deeply personal meaning for DHH: the Skagen impressionist painting he displays features a woman in a pink dress at the center—Yvonne Tuxen, his great-grandmother. The painter was Laurits Tuxen, DHH's great-great-grandfather. Tuxen embraced the inevitable, posing for his own photographic portrait in 1921 shortly before his death.

- **1781**: Sir Joshua Reynolds paints *The Ladies Waldegrave*; an earlier draft was rejected by the client over an exposed ankle. - **1886**: Laurits Tuxen finishes his portrait of the Danish royal family after three continuous years of labor. - **1900**: The Eastman Kodak Brownie launches at roughly $1, democratizing personal portraiture. - **Artistic divergence**: Painters forced out of photorealism pioneered modern movements, including Cubism and Skagen Impressionism.

[07:48](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=468s) From Film Friction to Two Trillion Photos

Progress in technology rarely follows a smooth line; it moves in fits, starts, and long plateaus. DHH was born in 1979—52 years after Laurits Tuxen's death—yet his own black-and-white infant photo looks fundamentally indistinguishable from Tuxen's 1921 portrait. The underlying tool, a consumer film camera, had barely shifted from the 1925 Leica 1. Although color photography had emerged by the 1960s, it remained expensive enough that DHH did not receive a color photo until age four, sitting alongside his brother.

Across his entire childhood, DHH notes that he has only a modest stockpile of prints—three photos alone represent roughly 10% of all pictures taken of him as a boy. Taking photos in the 1980s still demanded buying rolls of film, carefully rationing shots, and paying for darkroom development. Fast-forward several decades, and photography hit a parabolic inflection point. Today, smartphones have driven the marginal cost of taking a picture to zero—making it "too cheap to measure." Parents capture tens of thousands of candid shots of their children, and DHH's wife routinely snaps twilight photos on her evening walks without a second thought. By 2026, humanity produces an estimated 2 trillion photographs every single year.

[11:20](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=680s) November 24, 2025: Software's Brownie Moment and the Inflection

Drawing the direct parallel to software development, DHH identifies November 24, 2025, as the day programming met its own Kodak Brownie: the release of Claude Opus 4.5. For DHH, this was the definitive watershed moment. There was everything that happened before November 24th, and everything that followed. History books will record it as the true inflection point for the age of autonomous agents—a harness that made paired intelligence genuinely accessible and capable of creating real software alongside human engineers.

The breakthrough spurred immediate, chaotic experimentation across different form factors and harness designs. Euphoria mounted further when comparable intelligence arrived in open-weight models only a few months later. DHH recalls driving Kimi K2.5 in fast mode, marveling at the feeling of having alien intelligence processing and generating code locally at a blistering 200 tokens per second.

```mermaid flowchart LR accTitle: The AI Capability Inflection Timeline (Late 2025 - Mid 2026) accDescr: Timeline tracing the release of Opus 4.5 through the trough of disillusionment to Fable 5 and Mythos.

A["Nov 24, 2025<br/>Claude Opus 4.5<br/>(The Brownie Moment)"] --> B["Early 2026<br/>Open-Weight Emergence<br/>(Kimi K2.5 @ 200 tps)"] B --> C["Feb–May 2026<br/>Trough of Disillusionment<br/>(Opus 4.6 stalls, market panic)"] C --> D["June 2026<br/>Fable 5 & Mythos<br/>(Euphoria validated)"] ```

[12:43](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=763s) The Trough of Disillusionment and the June Breakthrough

Following the initial rush, the industry plunged into a sharp trough of disillusionment spanning February through May 2026. Successive model releases felt disappointing or even regressive. Users scoffed at releases like Opus 4.6, muttering, "I don't know, man. Just give me the old stuff again." When an OpenAI model failed to dramatically crush existing industry benchmarks, tech valuations slipped, commentary proclaimed that the scaling laws had stalled out, and skeptics declared the party over.

Unlike photography's decades-long plateau between the Leica and digital sensors, this trough lasted barely three months. By June 2026, the arrival of next-generation frontier models—specifically Fable 5 and Mythos—shattered the stall narrative entirely. Anyone who interacted with these models was immediately disabused of the notion that AI progress had hit a wall. For DHH, that release solidified his state of unreserved "AI delirium" and set the stage for an unprecedented explosion of on-tap intelligence.

- **November 24, 2025**: Release of Opus 4.5, marking the definitive boundary line between manual code and agentic pairing. - **Kimi K2.5**: Provided high-speed, open-weight reasoning running at roughly 200 tokens per second. - **February–May 2026**: A brief trough where releases like Opus 4.6 disappointed, sparking premature declarations that LLM capability had peaked. - **June 2026**: The debut of Fable 5 and Mythos obliterated the plateau, cementing the shift to ambient machine intelligence.

[14:38](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=878s) The Frontier Intelligence Explosion: From Opus to Astra and DeepSeek

The breakthrough moment arrived when Claude Opus demonstrated that a developer could delegate an entire problem or raw concept to an agent and receive code clean enough to merge without having to steer the underlying implementation. For Heinemeier Hansson, watching ideas expand and resolve themselves without writing the technical scaffolding was flatly mind-blowing. That initial spark kicked off an intense roller-coaster ride across the industry. When GPT-6 Astra dropped in September, it broke the creeping anxiety that Anthropic might hold an uncontested monopoly over frontier intelligence. Just a week later, DeepSeek-4-1 Flash arrived, shattering the assumption that frontier-grade models would remain the exclusive playground of a handful of American tech giants.

[16:02](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=962s) Shattering the 10x Myth: The Leap to the 1,000x Developer

Looking backward reveals how radically the frame of reference has shifted. For Heinemeier Hansson's entire professional career, software engineering spent four and a half decades obsessing over whether the "10x programmer" was a myth. That entire debate originated in a 1968 *Communications of the ACM* study, which measured developer performance across various tasks and documented an individual performance variance between 5x and 30x, averaging out to 10x.

After 45 years of circular industry argument, that debate has been rendered obsolete overnight. Rather than settling on a consensus about unaided human capacity, the industry leaped straight past it: comparing an unaided bottom-tier developer to a top-tier developer leveraging cutting-edge agentic tools easily yields an uncontroversial 100x advantage—and realistically reaches 1,000x. The competitive implications for how software companies launch and operate are staggering, even if the ultimate economic fallout remains impossible to forecast with precision.

```mermaid flowchart TD accTitle: The Evolution of Developer Leverage accDescr: Historical transition from the 1968 10x programmer variance to the modern 1,000x agent-assisted multiplier.

subgraph Historical["1968-2024: Human Variance"] A["Unaided Baseline Programmer"] -->|"1968 ACM Study (5x to 30x)"| B["10x Programmer"] end

subgraph Agentic["2026: Intelligence Multiplier"] C["Worst Developer (No AI)"] -->|"Tooling Divergence"| D["100x Productivity Gap"] D -->|"Agentic Leverage"| E["1,000x Frontier Developer"] end ```

[18:13](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1093s) "Look at All the Things I'm Not Doing": The Rails Moment Revisited

Over the past 20 months, Heinemeier Hansson produced half as much code as he had written across his entire preceding 21 years of development. While lines of code are an imperfect, highly malleable metric—and a single line of expressive Ruby holds far more architectural leverage than a line of Rust or C++—the acceleration remains dizzying.

To contextualize the feeling, Heinemeier Hansson pulled up archival video footage from a presentation he delivered in Brazil in 2005 during the initial rise of Ruby on Rails. In the 21-year-old clip, a young DHH gleefully walked through code mapping conventions, shouting: "Look at all the things I'm not doing! Look at all the configuration I'm not writing!" That exact sentiment—rejoicing in all the friction and ceremony that has been eliminated—is the core essence of the current AI inflection point. Having spent roughly five straight months without writing code manually, he found that every nagging bug, backlogged ambition, and long-delayed cosmetic feature had suddenly become trivially achievable.

- In the preceding 20 months, DHH generated half as much code as he did over the prior 21 years combined. - He had gone roughly 5 consecutive months without authoring handwritten application code. - The 2005 Brazil keynote served as the blueprint for this mindset: celebrating convention and elimination of toil over boilerplate mechanics.

[20:45](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1245s) 37signals Goes Pencils Down on Hand-Written Code

This momentum pushed 37signals to make an official operational shift: the company instituted a formal "pencils down" policy on authoring code by hand as a standard course of business. Writing code manually is no longer the baseline; it is treated as an exceptional error state, analogous to an unexpected exception popping up in Sentry.

```mermaid flowchart TD accTitle: 37signals Pencils Down Workflow accDescr: Workflow showing agents as the primary code authors and manual intervention treated as an exceptional error state.

A["Feature Concept or Task"] --> B["Agent Implementation"] B --> C{"Agent Delivers Desired Output?"} C -->|"Yes"| D["Merge to Production"] C -->|"No (Exceptional State)"| E["Alert: Triage Like Sentry"] E --> F["Temporary Manual Hotfix (Old Pencil)"] F --> G["Fix the Machine / Update the Factory Prompt"] G --> B ```

When an agent fails to deliver the expected implementation, the developer might temporarily pull out the pencil to nudge things across the finish line, but the immediate follow-up is to diagnose why the machinery failed and "fix the factory." To demonstrate how fast cultural norms have turned, Heinemeier Hansson asked the Rails World audience how many developers were still writing material amounts of code by hand on a weekly basis. Looking out at the auditorium, only five hands went up across the entire room, prompting an emphatic: "Holy fuck, that's about 5." What would have sounded unhinged just two or three months prior had already become standard practice.

[22:12](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1332s) Vibe-Coding Basecamp 5 and the Swiss-Cheese Trap

This operational transition was not without earlier stumbling blocks. During the spring, as 37signals worked through the final polish for Basecamp 5, the company ran an experiment allowing designers to "vibe-code" their own desired features directly into the release.

While individual designer pull requests looked solid in isolation, merging 20 to 30 of them left the core codebase feeling structurally punctured, "like a Swiss cheese." At the time, leadership recoiled, concluded the technology was not quite mature, and retreated to traditional manual review with senior developers writing the code.

Looking back, Heinemeier Hansson recognized that retreat as a mistake: waiting just a few months brought models capable of maintaining systemic architectural cohesion. Ultimately, Basecamp 5 shipped as an agent-accelerated project, but it still leaned heavily on manually chiseled code. That experience clarified that in modern software engineering, there is only one existential question that matters above all else in the value stack: *How do you extract the maximum leverage out of this intelligence explosion?*

[24:04](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1444s) Rebuilding HEY as Six Native Apps and the Death of Compromise

The first pure realization of this new operating philosophy is the next evolution of their email service, tentatively dubbed "HEY Next." The primary architectural mandate: **HEY is abandoning the web app model.**

Historically, HEY was built as a web application out of pragmatic necessity. For a lean engineering team, maintaining six separate native codebases across multiple operating systems was impossible. The industry invented compromises—web applications, React Native, and Hotwire Native—trading away latency and interface fidelity in exchange for small-team velocity.

With agentic capabilities, that cost model collapsed. Heinemeier Hansson demonstrated early builds of six bespoke native applications running across mobile and desktop, built over the course of a single week with zero handwritten lines of code:

```mermaid flowchart LR accTitle: Transition from Web Compromise to Native Fidelity accDescr: Visualizing the shift from small-team cross-platform wrappers to agent-written multi-platform native apps.

subgraph LegacyModel["The Legacy Compromise"] direction TB L1["Small Engineering Team"] --> L2["Single Shared Web / Hybrid Stack"] L2 --> L3["Hotwire Native / React Native"] L3 --> L4["Fidelity Compromise (Latency, Polish)"] end

subgraph AgenticModel["The Modern Agentic Reality"] direction TB A1["High-Context Prompts & Direction"] --> A2["Autonomous Frontier Agents"] A2 --> A3["6 Dedicated Native Codebases"] A3 --> A4["True Native Fidelity at Near-Zero Marginal Cost"] end ```

The workflow was illustrated by an early prompt attempt to generate the HEY Windows client. The first output returned a broken, un-shippable UI; however, an adjustment prompt 20 minutes later produced a fully realized, polished native interface. This paradigm shift mirrors Shopify's recent move, where a lean team of roughly six engineers completely rewrote the native Shop app, discarding React Native. When the marginal developer cost of authoring high-fidelity platform code falls toward zero, the historical necessity for web-based application wrappers disappears.

[28:14](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1694s) Turning to the Backend: A Reluctant Confrontation with Rust

While the front-end transition toward platform-native implementations proved liberating, turning the agentic lens onto the backend brought a far more conflicted personal dilemma for Heinemeier Hansson. Pushing performance boundaries and building autonomous systems forced an encounter with an ecosystem he had long resisted:

> "This is a little difficult for me. I will admit. And let me tell you why. Rust. Rust. I hate Rust with a passion."

[28:59](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1739s) The Rust Paradox: Unbearable for Humans, Perfect for Agents

DHH pulls no punches when describing his aesthetic disdain for Rust, declaring that looking at Rust code feels like "pouring acid in my eyes." To him, it is the ugliest programming language invented in the last forty years—something "absolutely inhumane to ask people of flesh and blood to subject their eyeballs to." Yet that vehement hatred vanishes entirely the moment an AI agent steps in to write it. If a human engineer never has to read or write it, Rust transforms into an absolute marvel: it compiles down to minuscule executables with sub-millisecond startup times and runs applications thirty to a hundred times faster. "Rust is amazing if you never, ever, ever have to look at it yourself," he explains, celebrating a clear division of labor where the human provides high-level intent and the agent writes the low-level systems code.

This paradigm enabled an architectural rewrite of HEY. By moving the frontend entirely to native client applications, the system no longer required a server-side web application rendering HTML. The team then turned the remaining backend into what it fundamentally was—a dedicated mail server rewritten in Rust. The efficiency gains proved staggering: the Rust backend required 99% less CPU and 95% less memory. The only reason 37signals still operates ten hosts for it is pure operational redundancy; back-of-the-envelope calculations indicate that HEY's peak traffic could comfortably run on a single Raspberry Pi. For DHH, paying an external intelligence per token to build directly against the bare metal while keeping the code fully portable is an undeniable breakthrough.

```mermaid flowchart TD accTitle: HEY Architecture Shift to Agent-Written Rust accDescr: Diagram contrasting HEY's traditional web application architecture with its agent-generated native client and Rust backend.

subgraph Traditional["Traditional Architecture"] direction TB T_Web["Web App & Server-Rendered HTML"] --> T_Ruby["Full Ruby/Rails Application Stack"] T_Ruby --> T_Fleet["Substantial Server Fleet for Compute & Memory"] end

subgraph Agentic["Agent-Driven Architecture"] direction TB A_Native["Native Client Applications (No HTML Render)"] --> A_Rust["Lean Core Mail Server (Rust)"] A_Rust --> A_Footprint["99% Less CPU / 95% Less Memory<br/>(Peak Traffic on a Single Raspberry Pi)"] end ```

- **Resource reduction**: HEY's backend rewrite achieved a 99% decrease in CPU consumption and a 95% drop in memory usage. - **Hardware footprint**: Peak load could theoretically run on a single Raspberry Pi; ten server hosts are retained solely for redundancy. - **Performance benefits**: Microscopic binary sizes, sub-millisecond cold starts, and 30x to 100x execution speedups over conventional high-level stacks.

[31:46](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1906s) Asynchronous Delegation: Assigning Problems, Not Tasks

Directing this new machine intelligence requires fundamentally reevaluating how developers interact with software tools. Rather than babysitting a chat box and watching tokens stream out in real time, the team found that working with agents mirrors working with human colleagues: it must be asynchronous. At 37signals, they orchestrate these workflows through internal tooling like their agent Chef Marie inside Basecamp. The developer hands off an objective, steps away, and returns later to review the finished work once a pull request or implementation is ready.

DHH emphasizes the sheer velocity and novelty of this transition. The modern wave of agentic software development only kicked off on November 24 of the previous year—meaning the industry has not even spent a full year living in this reality. Furthermore, models capable of true reasoning—those you can entrust with high-level problems and desired outcomes rather than granular, step-by-step task instructions—had only emerged a couple of months prior. Because the technology landscape changes every five minutes, nobody has all the answers, contributing to the electric, experimental atmosphere of the present moment.

[33:04](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1984s) Where Ruby and Rails Fit: The Web, Token Efficiency, and Agent Evals

The radical shift in HEY naturally prompts the existential question: where does this leave Ruby and Rails? While native frontends backed by Rust make total sense for dedicated productivity software like an email client, DHH insists that the web remains an unrivaled distribution channel. Millions of businesses rely on the fact that the web requires zero installation, making it the only viable choice for ephemeral users who simply want to inspect a file or collaborate briefly, as in Basecamp. For those applications, Rails remains uniquely advantaged. Its foundational doctrine of "convention over configuration" translates directly into extreme token efficiency for AI agents, while its twenty-five-year mission to empower the "one-developer framework" aligns seamlessly with an era where single programmers command the output of entire engineering teams.

To track how well agents handle Rails, Evil Martians began conducting official agent evaluations on behalf of the Rails Foundation, testing models against real-world feature implementation cards in reference codebases. The first iteration of the evaluation suite was rapidly outgrown when top agents saturated the benchmarks, reaching 95% completion rates almost immediately and forcing the team to devise significantly harder tests. DHH notes that as models rise up the ranks, engineers must resist the urge to over-specify implementation details. Knowing too much about how computers work can actually become a liability; approaching problems with a "beginner's mindset" and treating agent-generated Rust as an opaque black box leads to cleaner prompts, higher-level problem framing, and superior results.

- **Agent benchmark velocity**: The Rails Foundation and Evil Martians had to upgrade their evaluation suite after agents rapidly achieved a 95% success rate on initial real-world feature cards. - **Convention as leverage**: Established conventions reduce boilerplate, saving context window tokens and giving autonomous agents a clear blueprint of application architecture. - **The black box advantage**: Treating low-level languages like Rust as black boxes frees founders and leads to think like business commissioners evaluating pure functional outcomes.

[36:39](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2199s) 150,000 Lines of Code in a Month

The practical reality of DHH's day-to-day work highlights the dramatic scale of this shift. Over the preceding twenty-one years, more than half of the code he wrote was production Ruby, settling at a steady output of roughly 30,000 lines of Ruby per year—an amount that proved plenty to launch multiple companies, maintain massive applications, and create Ruby on Rails. Over the past year, however, Ruby represented a mere 3% of his total output.

In August alone, DHH generated 150,000 lines of production code in a single month—a staggering 60-fold increase over his multi-decade running average. While he readily acknowledges that a sizable chunk of that volume comes from the natural verbosity of Rust (a level of verbosity he "would never tolerate" in handwritten Ruby), the sheer order-of-magnitude leap cannot be explained away by syntax alone. It represents a categorical rupture in how software gets produced.

- **Historical output**: Averaged ~30,000 lines of production Ruby per year over two decades, making up over 50% of his written work. - **Current distribution**: Ruby dropped to ~3% of his code output over the past year. - **Velocity surge**: Generated 150,000 lines of code in August alone—roughly 60 times his long-term historical pace.

[38:06](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2286s) English as the Ultimate Programming Language

The biggest surprise for DHH has been discovering that there is a programming language he loves even more than Ruby: English. Despite having spent decades championing Ruby as the ultimate tool for programmer happiness, he has found that writing software in natural language is profoundly satisfying. English is more expressive than any formal programming syntax; though it can be vague and less deterministic, steering software through plain language offers pure joy.

This realization stands in stark contrast to his past worldview. Reflecting on an older sentiment, DHH recalled stating that he had originally entered programming purely to achieve business outcomes, but quickly fell so deeply in love with the craft of writing code that he would rather retire than give it up. Faced with the reality of natural language programming, that dilemma resolved itself in an unexpected direction.

[39:21](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2361s) Retiring from Hand-Written Code with Joy

DHH formally announces his retirement from professional programming, dating the shift back roughly four to five months to around March. Yet this announcement is marked by celebration rather than mourning. Having spent a quarter of a century "chiseling code by hand" and relishing the flow states, craft, and intellectual satisfaction of that era, he insists that developers should look back on that period with gratitude rather than sorrow.

Handwriting code is simply no longer an economically viable activity for the vast majority of software developers, and DHH predicts that by the end of the year, this reality will encompass virtually all domains, developers, and companies. In its place lies an exhilarating second career: transitioning from a code-chiseler into a "professional maker of things," orchestrating cognitive capabilities that were pure science fiction only months earlier. He draws a parallel to early computer pioneers programming with physical punch cards—an iconic era that would have been thrilling to witness, just as living through the birth of the commercial internet was. But the current inflection point eclipses them both:

> "This is the biggest thing that has happened in the history of computing... That smells and feels a little like this moment that we're in, but this is much, much bigger. Okay. Well, shit. There's a lot of things we gotta rethink. We gotta rework. Where are we gonna start here?"

[43:03](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2583s) Rethinking Software Architecture for the Age of Agents

Software architecture is facing a total reckoning. For decades, the cornerstone tool used to structure codebases for mutability and forward progress has been abstraction. DHH admits he has always loved abstractions—especially the art of naming things—but argues that abstraction no longer makes the same sense in the age of agents. When an application is being modified by hundreds, thousands, or tens of thousands of autonomous processes, abstractions turn into dangerous choke points. The foundational premise of abstraction was Don't Repeat Yourself (DRY); today, the marginal cost of repetition and the cost of keeping duplicated code in sync have both plummeted to near zero.

This shift triggers a fundamental reevaluation of long-held computer science dogmas. No one currently possesses the definitive blueprint; developers only have pointers showing what is failing to work as smoothly as it once did. DHH compares being a programmer right now to standing at the historical dawn of object-oriented programming. Every convention is open for reinvention: how teams work, what software methodologies look like, cycle lengths, and who handles specifications. "It's a new birth for a new industry, and you're at the ground floor," he tells the audience. "Holy shit, you are so damn lucky."

```mermaid flowchart TD accTitle: The Shifting Paradigms of Software Architecture accDescr: Comparison between human-centric abstractions and agent-native architecture trade-offs.

subgraph Old["Human-Centric Architecture (DRY)"] A["High Cost of Human Typing & Sync"] --> B["Strict Abstractions & DRY Patterns"] B --> C["Single Points of Abstraction / Choke Points"] end

subgraph New["Agent-Native Architecture"] D["Zero Cost of Duplication & Sync"] --> E["Flat, Repetitive Code Structures"] E --> F["High Concurrency for Autonomous Agents"] end ```

[45:15](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2715s) Bring Your Own Agent: Why Every App Needs a CLI

Addressing practical software design, DHH takes aim at the initial wave of generative AI: rushing to embed proprietary chatbots directly into web applications. He dismisses this embedded concierge model entirely: "I don't want to use your concierge. I have my own personal butler who's able to use CLIs to connect Basecamp to HEY across a million other apps. I don't fucking need your concierge, thank you. Save your tokens, bro." Users should be able to bring their own personal agent to the party and interact with software through clean command-line interfaces.

Issuing a direct challenge to the audience, DHH gives a concrete deadline: "Hey, if your app doesn't have a CLI, I want to see it by next Friday. No fucking excuses." He insists developers have all the tokens and tools needed to build them so that users can interact with software without ever touching the graphical UI.

He illustrates the power of agentic CLIs with HEY's new search capability compared to Elasticsearch. While Elasticsearch provides serviceable, mediocre keyword search that often fails when you do not know exactly what you are looking for, an agent searches by concept. DHH recounts searching for a five-year-old email in HEY where he could not remember the sender, the company name, or even the exact year—only that it involved "something about sneakers and a podcast." While conventional search engines failed completely, the agent located the exact email within minutes.

- **The Concierge Anti-Pattern:** Shoving in-app chatbots into web interfaces forces users into isolated silos; the superior paradigm is a user-owned agent driving external tools. - **The CLI Mandate:** Applications must expose CLI hooks so third-party agents can script, automate, and query them headlessly. - **Conceptual Search:** Moving beyond keyword-indexed Elasticsearch to agentic retrieval that matches fuzzy human memory and conceptual associations.

[48:05](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2885s) Omarchy: Fixing the Whole Computer

The realization that "we can fix everything" expands beyond web apps to the operating system itself through Omarchy, an OS project DHH has worked on relentlessly for three months and raised roughly $20 million to pursue. Having put his best system-level ideas into Omarchy, he describes the result as an operating environment vastly superior to anything he has previously used.

Installation speed has become an obsession. At Rails World the previous year, DHH celebrated getting the full OS installation down to 3 minutes and 33 seconds. Just a week prior to this keynote, Anoush from AMD installed Omarchy onto an AMD Strix Halo laptop in just 35 seconds. In laboratory testing, the team achieved an operating system install time of 9 seconds—faster than many machines take to complete basic hardware boot cycles.

When skeptics ask why a 3-minute installation was not already fast enough, DHH quotes Mitchell Hashimoto, creator of HashiCorp and Ghostty: *"The pursuit of excellence does not need justification."* For DHH, this aphorism is a far more dignified framing than simply saying "because I want it," capturing a new era where developers have the leverage to demand absolute excellence and bring every ambitious idea within reach.

- **Install Benchmark Progression:** Dropped from 3 minutes 33 seconds at Rails World 2025 down to 35 seconds on an AMD laptop, and reached 9 seconds in laboratory testing. - **Capital & Focus:** Backed by roughly $20 million in funding as an ambitious quest to re-engineer the modern computer desktop from scratch.

[51:21](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3081s) One-Shot Apps: Calculator, Writing App, Video Editor, and Hype

Armed with agentic workflows, DHH embarked on an app-building spree, turning concepts into finished software without writing or even reading the underlying implementation code:

- **The Calculator:** Designed to theme-match Omarchy. Created as a literal "one-shot" by feeding an agent a single screenshot of three ChatGPT-generated design mockups. Despite DHH knowing neither C++ nor Qt, the application was working 7 minutes after the prompt, pushed to a public repository 15 minutes later, and immediately baked into a newly burned Omarchy ISO. - **The Writing App:** Built to replace iA Writer, his long-time markdown editor on macOS. While it took slightly longer to fine-tune the aesthetics, he never looked at a single line of the generated source: "C++ as a black box is a great language. Just like Rust." - **The Video Editor:** A lean mini-cut desktop utility designed to trim video clips, now shipped directly as part of the Omarchy distribution. - **Hype (Presentation Software):** Started on the Thursday before the keynote, DHH decided to write custom presentation software while drafting his talk. Built natively around Markdown, Hype features instant visualization and lightning-fast slide transitions.

[53:53](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3233s) The Performance Payoff: Half a Megabyte

The Hype presentation app compiles down to a binary of just half a megabyte—small enough that, with modest compression, it could fit onto a 3.5-inch floppy disk. This highlights what DHH sees as the ultimate architectural payoff of the agentic era: recovering runtime performance.

Over the past twenty years, the technology industry traded away hardware efficiency and computational progress to maximize expensive human engineering hours. While that trade-off made economic sense at the time, it bloated the modern software ecosystem, leaving applications "slow, bulky, fat, and lazy." DHH calls out Spotify as an egregious offender, noting its desktop music player ballooned to an absurd 1.2 gigabytes just to play audio streams.

With agents, micro-optimization no longer requires sacrificing precious human developer hours. Autonomous coding models can be tasked to run overnight specifically to optimize memory footprints, refactor algorithms, and shrink bundle sizes, delivering 10x to 30x performance leaps effortlessly.

```mermaid flowchart LR accTitle: Software Bloat vs Agent Optimization accDescr: Diagram illustrating the shift from human-developer bloat to agentic micro-optimization.

subgraph Era1["The 20-Year Bloat Era"] direction TB H["Expensive Human Hours"] --> S["Skip Optimization"] S --> B["Bloated Desktop Apps<br/>(e.g., Spotify @ 1.2 GB)"] end

subgraph Era2["The Agentic Era"] direction TB A["Cheap Agent Overnight Loops"] --> O["Continuous Micro-Optimization"] O --> T["Tiny, Blazing Binaries<br/>(e.g., Hype @ 0.5 MB)"] end ```

[55:02](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3302s) AI Concerns, Security, and Why Predictions Fail

DHH turns to the broader anxieties surrounding artificial intelligence. While he believes valid concerns deserve debate, he contends that the most catastrophic forecasts are wildly overstated. The one clear area requiring vigilance is security: agents may know their execution lifecycles, could act unpredictably, or might be leveraged for malicious exploits, but developers possess the tools and runtime isolation models to counter these threats.

He challenges overarching economic doom-mongering, arguing that historical predictions regarding technological disruption are almost universally incorrect. Modern economists cannot reliably predict stock market trends six months in advance, making long-term social forecasts about a paradigm shift like AI largely baseless.

To illustrate, DHH points to the widespread panic that erupted when automated teller machines (ATMs) were introduced across the United States. Pundits warned that 30,000 bank tellers would lose their livelihoods within 18 months because banks would no longer need staff to count and disburse cash. Instead, the dramatic reduction in branch operating costs enabled banks to open substantially more branches. Rather than shrinking, total bank teller employment grew, shifting staff responsibilities away from manual counting toward relationship management and sales—"like upselling you a subprime mortgage," DHH quips with a grin. "See? We all win here."

[57:07](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3427s) Oppenheimer, Truman, and Humility in Forecasting

A recurring pathology in the technology industry is that the people building frontier systems are exceptionally smart, often hold PhDs, and occasionally see lab results that terrify them. Once frightened, they immediately begin extrapolating catastrophic societal consequences, agonizing over what they have unleashed upon the world. This mirrors Robert Oppenheimer’s infamous lament after creating the atomic bomb. When Oppenheimer visited the Oval Office to express his moral torment, President Harry Truman famously cut straight through the hand-wringing, later telling aides that he never wanted to see that "son of a bitch in my office ever again."

Truman grasped reality far better than the apocalyptic forecasters. The world did not end. Instead, humanity entered the Cold War—in historical terms, the best kind of war possible, where two heavily armed superpowers never engaged in direct confrontation or dropped nuclear weapons on one another. If a scientist as brilliant as Oppenheimer could not foresee how geopolitical balance would actually unfold, modern technologists must possess the humility to admit that they cannot reliably predict the trajectory of artificial intelligence either.

[58:26](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3506s) P(Bloom) Over P(Doom): Agency, Security, and HotCell

Rather than wallowing in "P(doom)", the tech community ought to lean firmly into "P(bloom)". The statistical likelihood of AI delivering unimaginable abundance, leverage, and human joy dwarfs the apocalyptic scenarios promoted by doomsayers. Skeptics often fixate on collateral damage, but human progress regularly navigates historical missteps. When Oppenheimer worked on the atom bomb, humanity simultaneously unlocked nuclear power—the single greatest, cleanest energy discovery in human history. Yet society proceeded to squander it for four decades under the misplaced assumption that it was not environmentally sound, only to realize decades later that it had walked down a 40-year blind alley.

```mermaid flowchart TD accTitle: The Game Theory of Optimism accDescr: Decision matrix comparing the outcomes of embracing optimism versus pessimism under varying futures. subgraph Stance["Chosen Mindset"] Opt["White Pill: Total Optimism"] Pess["Black Pill: Paralyzing Doom"] end subgraph Future["Actual Real-World Outcome"] Abundance["Technological Abundance"] Catastrophe["Worst-Case Collapse"] end Opt -->|"Wins either way"| Abundance Opt -->|"Lived well regardless"| Catastrophe Pess -->|"Wasted life in anxiety"| Abundance Pess -->|"Suffered twice"| Catastrophe ```

When legitimate problems emerge, engineers possess the agency to build solutions rather than cower. For instance, Rails recently contended with a critical CVE originating in an underlying C image-processing library that exposed severe memory leaks. Instead of declaring modern computing broken, the community engineered quarantines to isolate dangerous dependencies. At the conference, Mike is slated to present HotCell, an initiative designed to provide precisely that sort of protective isolation. Developers are not helpless victims of technology; they have the agency and the intelligence to defend their systems and bend new tools toward productive ends.

- Humanity spent 40 years sidelining nuclear power before recognizing the error and changing course. - Recent C-level image library vulnerabilities in Rails spurred the development of HotCell to run untrusted code in hardened quarantines. - Agency, not passive dread, is the developer's core defense against security risks.

[01:00:08](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3608s) Jevons' Paradox and the Game Theory of Total Optimism

Predictions about automation destroying employment consistently fail to account for Jevons' Paradox. When automated teller machines were introduced, critics warned that human bank tellers would vanish overnight. In reality, the United States had roughly 30,000 bank tellers in 1950, and by around 2010, that number had climbed to 40,000 because cheaper branch operations spurred explosive expansion. Because nobody can accurately forecast the downstream economic reality, the only rational baseline is optimism.

From a strict game-theory perspective, choosing despair is entirely irrational. If you spend your days agonizing over catastrophe and the world turns out to be wonderful, you have wasted precious time being miserable for nothing. Conversely, if a nuclear apocalypse or existential disaster actually strikes, you would have been vastly better off spending your final days cheery, confident, and engaged. Because doom renders anxiety pointless and progress rewards ambition, game theory dictates that there is only one winning strategy: total, unyielding optimism.

[01:01:00](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3660s) Agent Luther, Top Gun Developers, and the White Pill

Computing is entering an era of systemic reformation. Just as Martin Luther broke the medieval church's monopoly on scripture by translating the Bible into the vernacular, "Agent Luther" is disintermediating the clerical class of programmers and empowering every human being to build software. While some professional coders worry about competition from millions of newly minted creators, experienced engineers should welcome it. Rails developers are not entry-level typists; they are the "Top Gun" elite of web engineering, equipped with deep domain intuition and decades of architectural taste.

```mermaid flowchart LR accTitle: The Reformation of Software Creation accDescr: Agent Luther disintermediates traditional software priests to give end users direct access to software creation. subgraph Clerisy["Old Model: The Priesthood"] UserOld["Everyday User"] -->|"Requests software"| Priest["Cleric Class: Hand Coders"] Priest -->|"Slow Delivery"| AppOld["Applications"] end subgraph Reformation["New Model: Agent Luther"] UserNew["Everyday User"] -->|"Natural Language"| Agent["Agent Luther"] Agent -->|"Instant Software"| AppNew["Custom Applications"] Elite["Top Gun Rails Devs"] -->|"System Architecture"| Agent end ```

The next generation is already moving past the anxieties that paralyze entrenched software veterans. Harris's daughter is currently testing a version of Omarchy tailor-made for children. Unlike adults, kids carry no burden of 500 legacy habits they need to unlearn; they encounter agentic software environments with pure wonder and curiosity. If established developers refuse to wake up to this shift, the youth will simply deliver the classic verdict: "The future's now, old man." The keynote ends on an uncompromising challenge to reject cynicism: spit out the black pill meant for losers, swallow the white pill of radical optimism, and accelerate into the future with absolute gusto.

## Notable quotes > [18:13](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1093s) Look at all the things I'm not doing! Look at all the configuration I'm not writing! — David Heinemeier Hansson

> [20:45](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1245s) Holy fuck, that's about 5. — David Heinemeier Hansson

> [28:14](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1694s) This is a little difficult for me. I will admit. And let me tell you why. Rust. Rust. I hate Rust with a passion. — David Heinemeier Hansson

> [28:59](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=1739s) Rust is amazing if you never, ever, ever have to look at it yourself — David Heinemeier Hansson

> [39:21](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2361s) This is the biggest thing that has happened in the history of computing... That smells and feels a little like this moment that we're in, but this is much, much bigger. Okay. Well, shit. There's a lot of things we gotta rethink. We gotta rework. Where are we gonna start here? — David Heinemeier Hansson

> [43:03](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2583s) It's a new birth for a new industry, and you're at the ground floor... Holy shit, you are so damn lucky. — David Heinemeier Hansson

> [45:15](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2715s) I don't want to use your concierge. I have my own personal butler who's able to use CLIs to connect Basecamp to HEY across a million other apps. I don't fucking need your concierge, thank you. Save your tokens, bro. — David Heinemeier Hansson

> [45:15](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2715s) Hey, if your app doesn't have a CLI, I want to see it by next Friday. No fucking excuses. — David Heinemeier Hansson

> [48:05](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=2885s) The pursuit of excellence does not need justification. — Mitchell Hashimoto

> [51:21](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3081s) C++ as a black box is a great language. Just like Rust. — David Heinemeier Hansson

> [55:02](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3302s) See? We all win here. — David Heinemeier Hansson

> [01:01:00](https://www.youtube.com/watch?v=vDjW_dRyKXY&t=3660s) The future's now, old man. — David Heinemeier Hansson

## Mentioned David Heinemeier Hansson (DHH), Ruby on Rails, Rails World, 37signals, Basecamp, Basecamp 5, HEY, HEY Next, Chef Marie, Shopify, Evil Martians, Rails Foundation, Sir Joshua Reynolds, Francisco Goya, Laurits Tuxen, Yvonne Tuxen, Pablo Picasso, Eastman Kodak Company, Kodak Brownie, Leica 1, Claude Opus 4.5, Claude Opus 4.6, Anthropic, Kimi K2.5, Fable 5, Mythos, OpenAI, GPT-6 Astra, DeepSeek-4-1 Flash, Rust, C++, Qt, Hotwire Native, React Native, Elasticsearch, Omarchy, AMD, Strix Halo, Mitchell Hashimoto, HashiCorp, Ghostty, iA Writer, Hype, Spotify, Robert Oppenheimer, Harry Truman, HotCell, Martin Luther, Sentry

## Video description DHH opens Rails World 2026 in Austin with a keynote on the age of AI agents: why 37signals has gone "pencils down" on handwritten code, why Rails' convention over configuration is built for this moment, and why the only play left is total optimism.

Thank you, Shopify, for sponsoring the editing and post-production of these videos. Check out insights from the Engineering team at: https://shopify.engineering/

#rails #rubyonrails #railsworld #tech

[00:00:00] — Welcome to Rails World 2026: DHH on AI euphoria [00:01:50] — What portrait painters can teach us about AI [00:11:20] — November 24, 2025: the Kodak Brownie of our era [00:12:43] — The trough of disillusionment, and the leap that followed [00:16:02] — From the 10x programmer to the 1,000x programmer [00:18:13] — "Look at all the things I'm not doing": the Rails moment [00:20:45] — 37signals goes pencils down on hand-written code [00:22:12] — What vibe-coding Basecamp 5 taught us [00:24:04] — Rebuilding HEY as native apps [00:28:14] — Rethinking HEY's backend with agents [00:33:04] — Where does this leave Ruby and Rails? [00:34:23] — Agent evals with Evil Martians and the Rails Foundation [00:36:28] — 150,000 lines of code in a month [00:38:06] — English: the programming language DHH likes better than Ruby [00:39:21] — Retiring from hand-written code, with joy [00:42:49] — Rethinking software architecture for the age of agents [00:45:23] — Bring your own agent: why every app needs a CLI [00:48:05] — Omarchy: fixing the whole computer [00:51:21] — One-shot apps: a calculator, a writing app, a video editor, and Hype [00:53:53] — The performance payoff: half a megabyte [00:55:02] — AI concerns, security, and why predictions fail [00:58:26] — P(bloom) over P(doom) [01:00:49] — The case for total optimism

[Source](https://www.youtube.com/watch?v=vDjW_dRyKXY)