Starts Nov 23Live Cohort 3 of Vibe Coding & AI Agents: 3 weeks, 9 live hands-on sessionsCohort 3 (Nov 23) →
ReleaseInsight · On RadarSimon Willison→ original

While AI Rewrote curl in Rust, the Original Got 300 Commits and 200 Bug Fixes

Daniel Stenberg, the author of curl, compared the pace of AI rewrites of his project with the ordinary work on the original. In just over three weeks, agents turned 185,000 lines of C into 340,000 lines of Rust. In that time, more than 300 commits landed in the real curl, including a little over 200 bug fixes. It is like forking a library and no longer receiving its patches: the clones do not have those fixes. If you are choosing an AI clone over a mature dependency, ask who will pull in the fixes.

AI-processed from Simon Willison; edited by Hamidun News
While AI Rewrote curl in Rust, the Original Got 300 Commits and 200 Bug Fixes
Source: Simon Willison. Collage: Hamidun News.
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceSimon Willison ↗
Editor-in-Chief
Agents185,000 lines of C → 340,000 lines of Rust, recounted by Stenberg himself
In curl over the same three weeks300+ commits and about 200 bug fixes
Stenberg's forecastabout 200 more bug fixes over the next month

Daniel Stenberg, the creator and longtime maintainer of curl (a network data-transfer tool and library embedded in a huge number of systems and devices), compared two processes. In the first, AI agents rewrote curl from C to Rust: 185,000 lines of C became 340,000 lines of Rust. In the second, the real curl team simply kept working on the original.

Imagine you copied an open source library and stopped receiving its updates: a month later, your copy has not a single new fix. That is roughly what happened with the AI clones of curl. If you are wondering whether to replace a mature dependency with a quick clone written by an agent, this short quote, which Simon Willison highlighted, shows the hidden cost of that decision well.

What exactly Stenberg counted

Both processes ran in parallel for a little over three weeks. In that time, the agents generated 340,000 lines of Rust from 185,000 lines of C. Stenberg says he recounted the lines himself. The Rust code came out almost twice as long as the source, but that is not a measure of quality, only of the scale of what was generated.

Meanwhile, more than 300 commits landed in the real curl project. A little over 200 of them are bug fixes. The maintainers also closed several vulnerabilities. Stenberg stresses that none of those two hundred fixes are in any of the Rust rewrites. He expects that another 200 or so bug fixes will pile up over the next month, and that several more vulnerabilities may be closed. His closing question, "will the clones be able to keep up?", is rhetorical, but it goes to the heart of the matter.

Why porting code is only the beginning

Any mature project is like an old house where every odd detail appeared after something broke. An extra check in networking code is most likely the trace of a real bug: a server behaved in a nonstandard way, a client crashed, someone found an attack vector. That knowledge is stored not in the syntax but in the history of bug reports, discussions, and tests accumulated over the years.

When an agent rewrites code, it reproduces the behavior it sees in the source. But the original does not stand still: while the clone is being written, the real project moves ahead by hundreds of commits. It becomes a race in which the follower has to do more than copy the current state. It also has to keep pulling in new fixes.

This matters especially for security. If a vulnerability is closed in the original but the clone lacks the fix, the clone's users stay exposed, even if the language itself is safer when it comes to memory.

What this means in practice

First, do not confuse generation output with a finished product. An agent can save weeks of manual code translation, but the measure of success is not "it compiles and passes some of the tests". It is "does the project receive fixes at the same pace as the original?"

Second, if you plan to migrate to another language (with or without AI), decide in advance who will maintain the result. A one-off port without a team, a bug tracker, and a process for handling vulnerabilities is a snapshot, not a living codebase.

Third, judge a project by its momentum, not by the volume of its code. The number of commits, the speed of response to bugs and vulnerabilities, and the activity of maintainers say more about reliability than the number of lines in the new language.

There are caveats. This is the opinion of one person, and the one with the biggest stake at that. He is talking about specific Rust rewrites of curl, not about every migration done with agents, and he does not claim that such attempts are useless. The quote also does not show how well the generated code is written, or whether the clones' authors try to port changes from the original. But the calculation, 185,000 lines against 300 commits and 200 bug fixes in three weeks, illustrates the main risk: generating code is cheap, but keeping it up to date is still expensive.

For founders and product managers, the takeaway is simple. If someone offers to replace a mature dependency with a quick AI clone, do not ask "how compatible is it today?" Ask "who will close the bugs six months from now?"

Story

Key Questions Answered

What exactly Stenberg counted?

Both processes ran in parallel for a little over three weeks. In that time, the agents generated 340,000 lines of Rust from 185,000 lines of C. Stenberg says he recounted the lines himself. The Rust code came out almost twice as long as the source, but that is not a measure of quality, only of the scale of what was generated. Meanwhile, more than 300 commits landed in the real curl project. A little over 200 of them are bug fixes. The maintainers also closed several vulnerabilities.

Why porting code is only the beginning?

Any mature project is like an old house where every odd detail appeared after something broke. An extra check in networking code is most likely the trace of a real bug: a server behaved in a nonstandard way, a client crashed, someone found an attack vector. That knowledge is stored not in the syntax but in the history of bug reports, discussions, and tests accumulated over the years. When an agent rewrites code, it reproduces the behavior it sees in the source.

What this means in practice?

First, do not confuse generation output with a finished product. An agent can save weeks of manual code translation, but the measure of success is not "it compiles and passes some of the tests". It is "does the project receive fixes at the same pace as the original?" Second, if you plan to migrate to another language (with or without AI), decide in advance who will maintain the result. A one-off port without a team, a bug tracker, and a process for handling vulnerabilities is a snapshot, not a living codebase.

ZK
Zhemal Khamidun — CPO at Alpina Digital, product manager of AlpinaGPT. Building AI products since 2019. Hamidun News is a pet project that grew into a production aggregator with 6,000+ readers.
✦ Unified AI Workspace · Nomad

Test Frontier LLMs & Autonomous Agents in One Workspace

Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.

Try Nomad AI →Launch Nomad Agent
What do you think?
Loading comments…