Campfire's agent-built Rust port tests whether Ruby's readability still pays

Why it matters

Hansson's Campfire port makes the agent-era language trade-off measurable, while its company-run benchmarks and small-scale testing show how much evidence remains between a fast port and a production verdict.

David Heinemeier Hansson, the creator of Ruby on Rails, had coding agents port Campfire into Elixir, Go and Rust, then asked whether a language's readability matters as much when people are no longer writing or reading most of the code. The Rust version of 37signals' chat app puts that question against an increasingly concrete trade: substantially higher benchmark throughput, alongside code Hansson says he never inspected directly.

Hansson first announced the Rust beta on September 29th. In an October 4th thread on X, he said that agents can write and validate code well enough to change the assumptions behind language and framework choices. He still prefers Ruby for his own hand-written code. His interest in Rust, he wrote, is as a "prompt compile target." That is a sharp turn for the Rails creator, whose career helped make Ruby's developer experience a selling point.

The experiment is open to inspection in the Campfire Rust repository. It is an implementation of Campfire, 37signals' group-chat product, and keeps the existing SQLite database, storage layout and signed cookies. The Rust build consolidates several runtime pieces into one executable, while retaining the Rails application's data and much of its interface. That makes the port a test of operational trade-offs as well as raw language speed.

What the benchmarks show

Repository benchmarks run October 1st report the Rust version serving a room page at 36,120 requests per second, versus 217 for Rails, a 166-fold difference in that specific test. Posting a message was 25 times faster, and a separate test with 10,000 connected clients reported 73 times as many chat deliveries per second. The repository says the results came from production images, identical seed data and four pinned hardware threads per app on one AMD Ryzen AI MAX+ 395 machine, using the median of three runs.

Those are 37signals' own measurements, not an independent benchmark or a record of production traffic. The test setup gives a useful comparison under controlled conditions; it does not establish that customers will see a 166-fold speedup, or that a real Campfire deployment needs that capacity. Hansson himself described the app as small and said the work ran on two personal subscriptions. In the thread, he estimated some conversions took under two hours, while qualifying that the codebase was small.

The Rust port retains the Rails app's database and cookie compatibility, and a repository parity harness compares rendered HTML, the live document structure, accessibility trees, assets, WebSocket frames and screenshots against Rails. Tests can check those observable behaviors without a person reading every generated line. They cannot, by themselves, demonstrate that future changes will be easy to diagnose, that untested workloads will behave the same way, or that the generated implementation will remain safe to change.

Hansson acknowledged drawbacks: Rust's compile times are slow, and he has no interest in learning its intricacies. He also argued that agents do not need frameworks for the same reasons human developers do. That claim shifts the framework debate from whether a tool makes code pleasant to write toward whether it helps agents generate and validate a working system. It leaves human operators responsible for deciding what to test, which trade-offs to accept and what to do when a test misses a failure.

A change in the work, not a verdict on Ruby

Hansson's position is more conditional than a declaration that Ruby has lost. In the X thread, he said he would still choose Ruby if he were personally writing the code. He also said he had not written code by hand in a while. The experiment measures his new workflow: delegate implementation, use automated checks to validate output, then judge the resulting application rather than the language's appeal to its author.

The Campfire port adds a more bounded test: reproduce an existing application's behavior across implementations, preserve its existing data, and measure the result. Its parity harness and repository make that test more inspectable than a claim that an agent simply "rewrote" an app.

The immediate practical case for the Rust version may be infrastructure consolidation. The repository says one executable replaces Ruby, Puma, Redis, Resque and Thruster in the deployment, while retaining the existing database and storage. That could reduce the number of moving parts for self-hosted Campfire operators. It also means that performance, deployment simplicity and developer familiarity are being bundled together in one comparison; the benchmark cannot tell an operator which of those benefits matters most for their installation.

Hansson's language experiment is persuasive as evidence that agents can produce working ports quickly and that a controlled benchmark can reveal meaningful implementation differences. It is not proof that human readability has stopped mattering. Someone still chooses the specification, decides whether the tests are adequate, handles production failures and maintains the system when its behavior changes. For now, the clearest shift is in where Hansson is willing to spend his own attention: less on the code's syntax, more on the result and the checks around it.