A solo developer took a text editor written in Go. He fed it to Anthropic’s latest model. Days later, he held a Rust version that passed the original test suite. The bill came to about $400.
The experiment that caught the industry’s eye
The post appeared online yesterday. Its author, who goes by aka-rider on Hacker News, described a deliberate process that sidestepped the usual pitfalls of large-scale language migration. He didn’t hand-translate functions one by one. He didn’t rely on simple pattern matching. Instead he forced the model to reason about data first.
“I kept joking that I would have learned Rust a long time ago, but C++ money is not enough for a decent fursuit,” he wrote in the original post on iurii.net. The humor masked a serious point. Traditional rewrites demand deep expertise in both languages. This one did not.
His target was a 65,000-line Go codebase for a terminal text editor. He added features during the process, tree-sitter support and extra syntax highlighters among them. The final Rust output exceeded the original size. Total spend reached roughly $650 once everything stabilized. Still a fraction of what a human team would charge.
The approach drew immediate attention. On Hacker News the thread climbed quickly, with engineers probing how verification worked and whether the result truly matched the source. Comments noted that agents often game test suites. This project avoided that trap.
The timing proved perfect. Only weeks earlier, Bun’s creator Jarred Sumner had used the same underlying model, then known as Fable 5, to convert more than half a million lines of Zig to Rust. That effort took 11 days, 6,500 commits, 64 parallel agents and $165,000. The Pragmatic Engineer documented the saga in detail, highlighting the preparation phase that produced a PORTING.md guide mapping Zig patterns to Rust equivalents.
Sumner’s rewrite delivered 128 bug fixes and a 2 to 5 percent speed boost. It also underscored a pattern. When the problem is framed as data transformation rather than line-by-line translation, the model can orchestrate its own workflow.
Yesterday Anthropic released Fable 5.1. The new version promises lower costs for cached reads, up to 45 percent savings on agentic workloads according to the company. It also improves performance on long-running coding tasks. TechCrunch covered the launch, noting reduced false positives in safeguards and support for zero data retention options rolling out later this year.
Developers on X reacted to the smaller rewrite with a mix of excitement and skepticism. One post calculated that Bun’s conversion could have theoretically cost far less with tighter planning. Another wondered aloud whether $10 worth of model time spent reviewing AI-generated pull requests might catch more issues than humans do today.
Yet the core idea persists. Treat code as data. Model its flows explicitly. Let the system operate on that representation.
The author laid out three steps. First, extract the data representation. Ask the model to describe the program through graphs, ontologies, hierarchical state machines, constraints or mathematical formulas. Anything that captures behavior without tying it to syntax.
Second, operate on that representation. Simplify state machines. Remove hidden communication channels. Encode invariants so impossible states become impossible in the target language.
Third, generate the new code from the refined model. The resulting Rust benefits from compile-time guarantees that the Go version could only approximate.
He encoded quality gates directly into the hierarchical state machines. Fable also ported a human-like fuzzing session that simulated realistic user interactions, including odd commands such as “ordering a lizard.” That fuzzing, combined with the mutants.rs mutation testing tool, provided confidence that behavior survived the translation.
“These $400 also include the tests,” he noted in a Hacker News comment. “Fable ported ‘human fuzzing session’ (the best bug hunter) from Go to Rust and used it to validate everything else.”
The first 80 percent arrived in one extended overnight run after careful planning. Additional features pushed the total beyond the original line count. The editor now runs faster in some cases and carries zero runtime panics where the Go version relied on convention.
Not every observer bought the story. One HN commenter called the post itself suspiciously well-written for a short technical note. The author replied that it was human-written and that the real value lay in the data-first method. “LLM-powered rewrites and huge refactors are better done using 1 additional step ‘convert the code to
Similar experiments have appeared before. One developer used the model to convert a Python terminal effects library to Rust, achieving a 9.6x rendering speedup and cutting startup time from 87 milliseconds to 2. The binary shrank to 3 MB with no dependencies.
Academic work points in the same direction. A recent arXiv paper on EvoC2Rust described a skeleton-guided framework for C-to-Rust translation that decomposes projects, generates type-checked stubs, then incrementally fills functions while repairing errors. It reported strong gains in compilation and test-pass rates on industrial-scale modules.
The pattern repeats. Pure syntactic translation struggles with context. Data-oriented approaches scale.
Of course limits remain. The author admits the result isn’t perfect Rust. It reflects the structure of the original Go more than a ground-up redesign. Learning the language still matters for future maintenance. Yet for organizations sitting on large codebases written in languages that have fallen out of favor, the economics have shifted.
Memory safety, performance and ecosystem access drive many Rust adoption stories. Manual rewrites have always been expensive. This method suggests a different calculus. Spend a few hundred dollars and a weekend of oversight instead of a year of engineering salaries.
The Bun project showed what happens at scale. The smaller editor experiment shows what an individual can achieve today. With Fable 5.1 now public and priced more attractively for repeated interactions, more teams will test the waters.
Some will discover that their domain fits the data-first mold. Others will hit edge cases where human judgment still wins. The interesting question is how quickly those boundaries move.
For now, one developer has a faster, safer editor and a story that engineers across the industry are reading closely. The code runs. The tests pass. The cost was low enough to make you wonder what else might be worth rewriting.
One Developer’s $400 Experiment Rewrites 65,000 Lines of Go as Rust With AI first appeared on Web and IT News.