---
title: "DHH's Campfire Shootout: AI Rewrites in Rust, Go, Elixir"
description: "DHH had AI agents port Campfire from Rails to Rust, Go and Elixir and found Rust fastest. What he actually claimed, and why it's worth taking seriously."
url: https://axiointelligence.com/blog/dhh_campfire_shootout
---

[← Blog](https://axiointelligence.com/blog)

Rust, Elixir, AI coding agents, benchmarks

# DHH's Campfire shootout: AI agents rewrote one app in Rust, Go and Elixir

Brice Ayres / October 4, 2026

Short answer

DHH had frontier coding agents port 37signals' open-source Campfire chat app from Rails to Rust, Go and Elixir, then shared benchmarks with Rust on top. His argument isn't that Ruby is bad: it's that if agents write the code and you no longer read every line, Ruby's productivity and joy matter less, and languages agents can't write well out of the box will struggle. The early pushback from the Elixir community is about how the ports were done, which is a fair question to ask of any benchmark.

David Heinemeier Hansson, the creator of Ruby on Rails, spent the last week doing something a lot of us have wondered about: he had AI coding agents rewrite a real Rails app in other languages, then compared how they performed.

The app is [Campfire](https://github.com/basecamp/once-campfire), 37signals’ open-source group chat product. The results landed on X today and started an argument. We’ll lay out what he did and what he claimed, in his own words, before getting into the critiques.

## What DHH actually did

On September 28, DHH posted that he’d been [running a beta of Campfire rewritten in Rust](https://x.com/dhh/status/2104633108092092880):

> The code itself is still ugly as sin, and 6x as verbose, but the conversion was free\*, and I never had to look at the Rust directly, so this is awesome

The Rust port lives at [basecamp/once-campfire-rust](https://github.com/basecamp/once-campfire-rust). Go and Elixir ports followed. Today he posted the comparison:

> I’ve had agents implement and optimize the Campfire web app in Elixir, Go, and Rust. Yes, Ruby is the slowest. I didn’t care about that when the pay-off was huge in terms of productivity and developer joy. But if you’re no longer reading the code? ([post](https://x.com/dhh/status/2106810173683851564))

He also described how little steering the ports got. Replying to José Valim, Elixir’s creator, he said the prompt was “just something like ‘Rewrite this in Elixir. Review with Codex. Optimize it.’ Same as what was used for Go, Laravel, Rust, etc.” ([post](https://x.com/dhh/status/2106883833773650428))

## The argument, in his words

It’s easy to read this as “Rust good, Ruby bad.” That’s not what he said. The argument has three parts.

**1\. Developer joy was the reason to accept slower code.** For two decades, the case for Ruby has been that the productivity and happiness were worth the performance cost. DHH still says that was the right trade *when humans wrote and read the code*.

**2\. If agents write it, the trade changes.** “I’m not saying that all apps need Rust levels of performance. Far, far from it! But I am saying that if agents are really good at writing Rust, and you’re onboard with agent acceleration meaning we don’t read all generated lines, then it’s a good argument for Rust!” ([post](https://x.com/dhh/status/2106844850742259736))

**3\. Languages agents struggle with will struggle.** This is the part aimed at Elixir and Go: “If your answer here is ‘frontier agents aren’t good at writing Elixir or Go’, then it only makes the argument worse. Any programming language that agents can’t write well out of the box is going to have a hard time in the future.” ([post](https://x.com/dhh/status/2106844184392991137))

He’s also clear this isn’t a personal conversion: “Do you know how badly I would hate having to personally write Rust?? But when the premise changes, you need to update your priors.” ([post](https://x.com/dhh/status/2106846641906978939))

And he’s invited fixes more than once. To one critic: “Please do send a PR to speed things up! But also realize that it’s not exactly extra points for Elixir if frontier agents can’t find the magic ‘go fast’ switches.” ([post](https://x.com/dhh/status/2106864061832991134))

## Why we take the argument seriously

Strip away the language war and there’s a real point here, one we see in client work.

- **Porting got cheap.** DHH says each conversion took “less than two hours” and produced “tens of thousands of lines” ([post](https://x.com/dhh/status/2106841744239194569)). Even if you discount that, a working port of a medium-sized web app is now days of work, not months.
- **Out-of-the-box agent quality is a fair test.** Most teams using agents won’t hand-tune prompts per language. If one language gets good results from a plain prompt and another needs an expert steering it, that’s a real cost.
- **Not reading every line is already happening.** Whether or not you like it, many teams are reviewing agent output rather than writing it.

## The first pushback

The Elixir community responded within hours, and the critique is about *method*, not the premise.

Christian Ertel pointed at the Elixir port’s database module, [`lib/campfire/db.ex`](https://github.com/basecamp/once-campfire-elixir/blob/main/lib/campfire/db.ex), and noted that its design “guarantees that every query is serialized into a single process mailbox” ([post](https://x.com/crertel/status/2106862177147650447)). In plain terms: every database call waits in one line.

Chris McCord, Phoenix’s creator, made a broader point: “Given campfire started as ruby, it’s going to be designed as stateless app,” and that’s not how you’d design a chat app in Elixir ([post](https://x.com/chris_mccord/status/2106865316899037391)).

And Tom Gosling looked at the repos and summarized the effort behind each port: “Rust: 3 human authors, 397 commits over 6 days, 32 perf experiments, free to diverge from Rails. Go: 1 author, a port of the Rust port, 2 days, 12 experiments. Elixir: 1 author, 1 day, one ~1hr tuning pass, kept Rails’ Redis and Thruster.” ([post](https://x.com/tomgosling/status/2106869782045925422))

That last point is the one to watch. If the ports didn’t get the same amount of work, the benchmark compares effort as much as languages.

## What to take away today

- **The premise stands on its own.** Agents changing the cost of a rewrite is real, and so is the question of which languages agents write well.
- **The benchmark needs a closer look.** Whether the comparison was apples to apples is a separate question from whether the premise is right. We’ll dig into that next.
- **DHH has asked for patches.** The repos are public, and there’s an open invitation to make the slower ports faster.

If you’re thinking about an agent-led rewrite of your own app, the most useful lesson is about process: decide up front how you’ll judge the result, and give every option the same chance. If you’d like help setting that up, [book a call](https://axiointelligence.com/book).

## We do this work for a living.

A 30-minute scoping call with the engineers who would do the work.

[Book a scoping call](https://axiointelligence.com/book)

Or email [contact@axiointelligence.com](mailto:contact@axiointelligence.com?subject=Project%20inquiry) and we’ll reply.

## Related posts

Oct 11, 2026

### [DHH's Campfire shootout, part 2: the Elixir port played by different rules](https://axiointelligence.com/blog/dhh_campfire_shootout_part_2)

The Campfire repos show Rust could drop Redis and diverge from Rails while Elixir PRs doing the same were turned down. What a fair benchmark needs.

Elixir, Rust, benchmarks

Oct 6, 2026

### [398 commits vs 2: how to run a fair language benchmark with AI-written code](https://axiointelligence.com/blog/fair_language_benchmark)

The Campfire Rust port had about 400 commits before the benchmark. The Elixir port had two. How to run a fair benchmark when AI agents write the code.

benchmarks, Rust, Elixir

Oct 10, 2026

### [Fast isn't the same as reliable: what the Campfire reliability test shows](https://axiointelligence.com/blog/fast_isnt_reliable)

A reliability test of the Campfire ports: Rust is fastest at light load but drops most messages under heavy load. Rails and Elixir delivered every one.

Elixir, Rust, reliability