"We're Done Writing Code by Hand": Rails Creator DHH's Agent-Era Manifesto

In brief: Ruby on Rails creator DHH announced in his Rails World keynote that 37signals has stopped writing code by hand. At this 27-year-old company, famous for software craftsmanship, hand-written code is now an "exceptional state" — like a bug popping up in Sentry. The manifesto, the inflection point, and the counter-evidence from the very same source are all in this piece.

One declaration: "We're done writing code by hand"

This may be the most symbolic moment in the AI coding conversation of 2026. At his Rails World keynote in the last week of September, Ruby on Rails creator David Heinemeier Hansson (DHH) announced a decision: 37signals has stopped writing code by hand. His exact words:

"We're done writing code by hand."

In his telling, hand-written code is now an "exceptional state" at 37signals. His metaphor is a good one: hand-written code appearing is like seeing a bug in Sentry (the error-monitoring tool). "Something went wrong here — why didn't the agent produce what we wanted?" That is not a programmer's grumble; it is a new engineering signal: anywhere a human has to write code by hand means there is a break somewhere in the automation chain.

Why does this carry weight? Look at who is talking. 37signals is a 27-year-old company: profitable, un-funded, independently run, and — crucially — famous in the industry for software craftsmanship and code quality. DHH himself is the standard-bearer of the "code as craft" school in programmer culture: he wrote Rework, railed against factory-style development, and hand-built Rails into the most elegance-obsessed web framework there is. When a craftsman-in-chief announces the retirement of the craft, it is not a hype-chasing startup shouting slogans. It is an industry earthquake.

He has even redefined his own identity: "I have retired from being a professional programmer." The timing was about four to five months ago — around March 2026. Before that, he says, he spent "a quarter of a damn century chiseling code by hand." Note the word "chiseling": a craftsman's verb. He has now put it in the past tense.

The inflection point: November 24, 2025, the "Kodak Brownie" moment

DHH pinned a specific date on the arrival of the age of agents: November 24, 2025, the day Anthropic released Opus 4.5. He called it the industry's "Kodak Brownie" moment — "the inflection point for the age of agents."

The metaphor deserves unpacking. The Kodak Brownie camera (introduced in 1900) turned photography from a professional darkroom craft into a press-the-shutter mass activity: the technical barrier collapsed, output exploded, and the standard of "a good photograph" was reinvented in the process. DHH's point is blunt: Opus 4.5 is programming's Brownie. It did not make coding a bit faster; it turned "writing code" itself from a craft into pressing a shutter. Before the inflection point, agents were toys and assistants; after it, agents are the default mode of production, and the human is the exception.

He delivered his verdicts one after another, each sharper than the last:

"Writing code by hand is no longer an economically productive enterprise for the vast majority of programmers."

Translation: for the vast majority of programmers, writing code by hand no longer pays, economically speaking. This is not a claim that hand-written code is low quality; it is a claim that it has lost on economics — in the same amount of time, agents produce more code, more cheaply, and economic rationality crushes all sentimentality.

The other one cuts deeper:

"Abstractions don't make quite the same sense in the age of agents… the price of repetition has gone to near zero."

Abstractions don't make quite the same sense anymore, because the price of repetition has gone to near zero. Decades of software engineering wisdom — DRY, abstraction, reuse — were built on one premise: repetition is expensive, and human time is more expensive still, so we use abstraction to kill repetition. But if an agent writing something ten times costs almost the same as writing it once, the value proposition of abstraction changes. This does not mean abstraction is dead; it means the economic assumptions under which we invented abstraction are being rewritten.

What they have already turned the company into

A manifesto without organizational action is keynote rhetoric. 37signals' actions number three, and each is counter-intuitive:

First, embracing native iOS and Android apps. 37signals historically shipped web-only apps and kept a respectful distance from native development. The reason was pragmatic: native development is expensive — two codebases, two skill sets, more than a small profitable team can afford. But agents changed the equation: if agents can produce code for both platforms, "a small team shipping native" goes from luxury to routine. This directly dismantles the old constraint that team size dictates product shape.

Second, moving backend services from Ruby to Rust. This hits especially hard coming from DHH's mouth — he is the godfather of the Ruby world; Rails is his creation. Now he says: "agents write good enough Rust." Consider the subtext: the criteria for choosing a language have changed. Teams used to pick languages by familiarity, ecosystem, and hiring market; now the criterion is "what do agents write well?" Rust is famously hard to learn — the borrow checker torments humans — but for agents, a strict compiler is a feature, not a bug: the more precise the error messages, the better the agent's self-correction. Languages humans find hard, agents may find just right.

Third, keeping Rails for web apps. This is not nostalgia; there is a technical reason. Rails' convention-over-configuration design is unusually agent-friendly. Fixed directory structure, disciplined naming, best practices baked into the framework — the agent never has to guess intent in a freewheeling codebase, because the framework has already nailed intent down. This hands every framework author a new KPI: is your framework agent-friendly? The framework competition of the next decade may first and foremost be a competition in "agent readability."

The counter-evidence, from the same newsletter: it's not that simple

Interestingly, the same issue of The Pragmatic Engineer that reported the keynote came with two pieces of counter-evidence right after. That makes it impossible to write "the death of hand-written code" up as a marketing piece.

Counterpoint one: an anonymous Big Tech engineer's rant. An engineer at a large tech company (speaking anonymously via voxium) described his daily life: specs, code, tests, PRDs — all generated by Claude Code. He works 12 to 13 hours a day doing "just to press enter." His summary is a single sentence:

"Nobody is thinking anymore."

Nobody is thinking anymore. This is the sharpest rebuttal to DHH's manifesto: if agents do the writing and humans do the enter-pressing, is the "thinking" step even still there? DHH says hand-written code is the "exceptional state"; this engineer says "thinking" is becoming the exceptional state. When the volume of generated code exceeds what any human can review, "human in the loop" becomes an empty phrase — the human occupies a box on the flowchart but gates nothing in practice.

Counterpoint two: Uber Eats shipped a mess. In the same week, a new Uber Eats feature went live with at least three low-grade bugs in front of users — one of them a UI label reading "Choose up to 999." That is the kind of error any QA who glanced at the screen for a second would have caught. Its presence in production says one thing: quite possibly, nobody looked seriously. A launch with seemingly no QA pours a bucket of cold, production-incident-flavored water over the "agents run everything" narrative.

Put these two next to DHH's manifesto and the picture is complete: the productivity of the agent era is real, and the inflection point is real — but so is the organizational disease of "nobody thinking, nobody QA-ing." The question was never "are agents good enough"; it is "how many people in the organization are still actually responsible for anything."

The verdict: three takeaways for vibe coding readers

By now, the vibe coding reader (that's you, my friend) should be asking not "is DHH right?" but "what does this mean for how I write code?" Three judgments, for reference:

1. Demote "hand-writing" from default action to exception signal

DHH's most actionable idea is not the manifesto — it is the Sentry metaphor. Don't treat it as rhetoric; treat it as workflow. Next time you catch yourself about to hand-write a piece of code, pause for three seconds and ask: why didn't the agent get this done? Was the prompt unclear? Was the context insufficient? Or is this a problem agents shouldn't be doing at all? In the first two cases, fix your prompt engineering; only in the last case is hand-writing justified. Over time you will build your own "must hand-write" list — and the shorter that list gets, the more agent-native you have become. 37signals has compressed that list to "exceptional state." That is the destination, not the starting point.

2. Pick agent-friendly stacks, not sentimental ones

37signals' logic for keeping Rails and moving to Rust translates into personal-developer language like this: add one more criterion to your stack choices — "do agents write this smoothly?" Convention-over-configuration frameworks (Rails, Next.js's App Router conventions, strict TypeScript setups) let agents guess less and get more right; strictly typed languages (Rust, TypeScript strict mode) give agents something to grab onto for self-correction. Conversely, a legacy codebase held together by unwritten tribal knowledge is hell for agents — they cannot guess what was never written down. So the number-one productivity factor in vibe coding is sometimes not a better prompt, but a more "agent-readable" project structure.

3. Never fire QA — even when QA is you

This is the lesson of those three Uber Eats bugs and that engineer pressing enter for 13 hours — and the other half of DHH's manifesto that he didn't spell out: 37signals can afford to say "done writing code by hand" because it stands on 27 years of engineering discipline — a code review culture, testing traditions, a shared consensus on what "good code" means. Agents amplify the engineering habits you already have: good habits, good code; bad habits, bad code at ten times the speed, gift-wrapped in the illusion of correctness.

For the individual developer, the rule simplifies to one sentence: agents may write for you, but they cannot be responsible for you. A bug like "Choose up to 999" costs 30 seconds of human eyes to stop, and one public embarrassment to let through. Vibe coding is not "just vibe and you're done" — vibe is the starting point; the last look before shipping must always be human.

One detail that's easy to miss: DHH said "the vast majority of programmers," not all of them. He left an exception in the proposition — the people who define problems, design systems, and make final calls. Vibe coding readers sit naturally inside that exception: you are not someone writing CRUD on an assembly line; you are a one-person team. For you, the agent is not a replacement but a lever. The question about a lever was never "use it or not" but "where do you put the fulcrum" — and the fulcrum is your judgment. The stronger the judgment, the longer the lever.

One last nerdy contrast: DHH's choice of the "Kodak Brownie" metaphor hides a warning. Kodak invented the digital camera — and was killed by the digital camera — because it treated the new technology as a garnish on the old business. Programming stands at the same fork now: those who use agents as "faster autocomplete" and those who use them as "a new mode of production" will be in completely different places five years from now. 37signals chose the latter, at the price of burying 25 years of its own craft. You, the vibe coder, arrived with nothing to bury — that is your advantage. Don't waste it.

So how should DHH's manifesto be read? Read it as two sentences. The first is a statement of fact: the economics of agent-written code have already won, and fewer and fewer people will hand-craft everything against the tide. The second is a value judgment: "done writing by hand" does not mean "done thinking" — quite the opposite. When the cost of writing code approaches zero, the things that cannot be written — thinking, judgment, taste — become, for the first time, the programmer's true scarce resource. That anonymous engineer said "nobody is thinking anymore"; DHH would say: that is exactly the problem for you to solve — move thinking from "how to write it" to "what to build and why."

The era of hand-written code is over. The era of using your head has just begun.