Back to Explore
NewsVibeFix editorialUpdated Nov 19, 2026

Agents Rewrote 185,000 Lines of curl in Rust — the Maintainer's Answer: Writing Code Was Never the Hard Part

On 17 November 2026, curl maintainer Daniel Stenberg answered two agent-built Rust rewrites: 185,000 lines of C became 340,000 lines of Rust in three weeks — while curl itself merged 300+ commits and 200+ bug fixes. Writing the code was never the hard part; keeping it alive is.

Close-up of colourful lines of code on a dark screen, with syntax highlighting clearly visible

In short: the code is written, but the software is not alive yet

On 17 November 2026, Daniel Stenberg — the author and maintainer of curl — published a short post on his blog titled "Actual curl rewrites in rust". The trigger was simple: this autumn, two projects appeared that used AI coding agents to rewrite curl in Rust. The first, urlx, showed up a few months ago and calls itself "a memory-safe, from-scratch reimplementation of curl and libcurl". The second appeared in November, named "curl, rewritten in Rust" — it did not even bother to pick a different name — and claims to have spent 8,600 US dollars to get it done. Stenberg counted: in a little more than three weeks, the agents converted 185,000 lines of C code into 340,000 lines of Rust. In that same window, the real curl project merged more than 300 commits, fixed more than 200 bugs, and patched a few security vulnerabilities along the way. His conclusion was blunt: "Writing code once was never the big deal with software and it still isn't."

This is worth writing about not because there is one more Rust rewrite, but because it happens to be a rare controlled experiment. One of the most common questions in vibe coding circles is: can you get an agent to rewrite an entire project — a different language, a different framework, a different style? Normally that question can only be argued about in the abstract, because there is no control group. This time the control group showed up on its own: in the same window of time, agents rebuilt a 25-year-old project from scratch on one side, while the original project kept moving forward on the other — with its users, its tests, and its maintainers. Stenberg is not judging from the sidelines; he is the person merging the commits and fixing the bugs every day. The numbers he sees are not the same as the applause on social media.

First, the numbers: 185,000 lines became 340,000, for a claimed 8,600 dollars

Let us get the facts straight first. The first rewrite, urlx, was created in March 2026 by jonwiggins; when checked on 19 November it had just 25 stars, and its description reads "A memory-safe Rust reimplementation of curl and libcurl". The second rewrite appeared in November, reused the curl name outright, and claims to have spent 8,600 dollars — note that this is the project's own claim, which Stenberg merely relays without vouching for it, and this article does not treat it as a verified cost. Combined, the figure Stenberg counted himself is: 185,000 lines of C became 340,000 lines of Rust, an expansion of about 1.84 times.

Line-count growth by itself proves nothing about quality. Rust is inherently more explicit than C — error handling, type annotations, and lifetime management all stretch code out. But the 1.84x figure is still worth a second question: of the extra 155,000 lines, how much is explicitness the language itself demands, and how much is filler carried in by the translation — glue code stacked up to make the tests pass, duplicated conversion layers, repeated logic that nobody has merged yet? Stenberg does not answer that, and neither does this article. The numbers with real weight are on the other side: in the same three-plus weeks the agents spent translating, the curl project merged more than 300 commits, over 200 of them genuine bug fixes, plus a few vulnerability fixes. In Stenberg's own words: "200 bugfixes that none of those rust rewrites have." The rewrites have none of those 200-plus fixes.

Comparison chart: while agents translated 185,000 lines of C into 340,000 lines of Rust, the curl project merged 300+ commits and 200+ bug fixes in the same period; of 81 curl vulnerabilities confirmed in 2026, only 14 could likely have been avoided by memory safety

The maintainer's three judgements, each puncturing a vibe-coding illusion

Stenberg's post is short, but it contains three judgements, each worth reading carefully if you build things with agents. The first is the line under the heading: "Writing code once was never the big deal with software and it still isn't." His reasons are concrete: the world's AIs have trained on curl code for years; curl is extremely well documented; hundreds of open-source applications use its API; and there are thousands of test cases to verify an implementation again and again. Under those conditions, what the agents had to do was essentially translation — convert existing C code into Rust and polish it until the tests pass. Translation takes real skill, and finishing 185,000 lines in three weeks is an impressive engineering feat, but it is a completely different thing from "creating a curl from nothing". The first has an answer key to copy from; the second does not.

The second judgement is: "curl is the result of time." What curl is today comes from countless decisions, long stretches of time, many users, oceans of feedback, and round after round of iteration. Recreating curl as it stands at one specific moment is certainly doable — because the project has written itself an almost perfect specification: documentation, API contracts, and a test suite, all present and correct. But read the other way, that sentence is also a challenge to every vibe-coded project: does your project have a "perfect specification" like that? Most vibe-coded projects do not. Tests are added afterwards, documentation is improvised by the model, and the agreements between APIs live only in some chat transcript — or only in the author's head. Ask an agent to rewrite such a project and it is not copying a specification; it is copying its own previous guesses, and errors get inherited in translation, or even amplified.

The third judgement stings the most, and is the easiest to drown out with applause: "Behind already." The rewrites were already out of date the moment they were finished. Stenberg puts it plainly: in another month, curl will have fixed another 200 bugs and patched a few more vulnerabilities — and will the clones keep up? curl averages about 11 commits a day, a pace driven not by one person's overtime but by the whole community of users, contributors, and maintainers. Stenberg even sketches a way out for the rewriters: they could follow curl's commits and convert them to Rust on the fly — 11 commits a day is, in theory, keepable-up-with. But the implication is that keeping up needs a maintenance team, not a one-off translation sprint. A rewrite with no users, no feedback loop, and nobody processing bug reports every day is destined to fall further and further behind.

The 17.3% figure is more worth remembering than the 340,000 lines

The post contains another set of numbers that deserves more attention than the line count, and is easier to misread. Stenberg writes that so far in 2026, curl has confirmed 81 security vulnerabilities, and 14 of them were "the result of mistakes that most likely would have been avoided had we used a memory-safe language such as rust" — 17.3%. In other words, even if curl had been written in Rust from the start, 67 of those 81 vulnerabilities would still have been there. Memory safety eliminates one class of errors — out-of-bounds reads and writes, use-after-free, double free. But most curl vulnerabilities are not in that class; they hide in protocol parsing, state machines, edge cases, and configuration combinations — logic-level places where the choice of language makes no difference.

That figure carries two warnings for people who build with agents. First, do not read "memory-safe" as "safe". A Rust rewrite genuinely makes one class of vulnerability disappear, but presenting it as a security story would mislead users into thinking the other 82.7% is gone too. Second, the vulnerability count is itself a report card for maintenance work: 81 vulnerabilities were "confirmed" — someone reported them, someone reproduced them, someone fixed them. A rewrite with no users and no security researchers looking at it has zero vulnerabilities — not because it is safer, but because nobody has looked. Which is more trustworthy: a rewrite with zero vulnerabilities, or an original with 81 confirmed and fixed? Stenberg's answer is embedded in the post: he would rather have the project that keeps getting challenged and patched.

Translation and creation are two completely different jobs

Hidden in Stenberg's post is a distinction that is easy to miss: translation versus creation. Translation has a source text: mistakes are caught by tests, gaps are flagged by documentation, and the definition of done is "behaves the same as the original". Creation has no source text: the definition of done is something you set yourself, and you often only learn whether it was right after users have tried it. Agents are already strong at translation — the curl story proves it: with a complete specification, a full test suite, and thorough documentation, agents delivered 340,000 lines in three weeks. But creation is a different job entirely: you first have to decide what the thing should be, then judge which details matter and which can wait, and finally take responsibility for every decision. No test suite can answer "should this feature exist", and no documentation can tell you "what do users actually want".

That distinction has direct consequences for everyday vibe coding. Asking an agent to "translate this Python script into Go" or "rewrite this jQuery code as React" is a translation task, with a high success rate — use it boldly. Asking an agent to "build me a tool nobody has built before" or "help me figure out what this product should look like" is a creation task, and what the model usually returns is the most common shape in its training data, not the shape that fits you best. Many vibe-coding projects fail exactly here: they treat a creation task as a translation task. A person gives the model one vague idea, the model fills in the details following the most familiar pattern, and the person only discovers at review time that none of those details are what they wanted. Stenberg's warning, restated, is: work out what you want first, write it down, turn it into tests, and only then let the agent build; otherwise the faster it writes, the more you will have to redo.

The two rewrite projects are also worth looking at separately. urlx appeared in March 2026 and had only 25 stars when checked on 19 November — more like a personal experiment in scale. The second project, which appeared in November, reused the curl name and claims to have spent 8,600 dollars; it makes more noise, but Stenberg states plainly that he has not been in contact with any of the rewriters and does not know what they plan to do next. There are a few publicly observable signals for judging whether these projects will be flashes in the pan or something that lasts: whether they build their own test suites and continuous integration; whether they track curl upstream's roughly 11 commits a day; whether they accumulate real users and bug reports; and whether their commit history keeps going after the launch buzz fades. None of those questions had answers when this article was written — readers can check the repositories themselves. A project's commit curve is more honest than its marketing copy.

What this actually means for people who build with agents

Taken together, Stenberg's three judgements answer one question: what have agents changed about software development, and what have they not changed? They have changed the cost of "writing the first version". An old project with a complete specification and a full test suite can now be translated into another language in weeks, for a few thousand dollars — that is real progress, and it is to urlx's and "curl, rewritten in Rust"'s credit. They have not changed the cost of "keeping software alive": understanding user feedback, fixing bugs, patching vulnerabilities, keeping APIs stable, processing 11 commits a day. That work has no answer key to copy and no test suite that can validate it for you; it can only be ground out, round after round, by people and a community.

For anyone building projects with agents, there are at least three lessons here. First, rewriting is a translation task, and it only fits projects whose specification is complete and whose tests are thorough; it does not fit new projects that are still being figured out. What a new project lacks most is precisely a specification — you do not yet know what you want, so the agent can only guess, and guessing translated a second time only welds the guesses in place. Second, maintenance speed is the real moat — not line count, not language choice. Taking over an agent-rewritten project means taking over a snapshot with no maintainer and no user feedback loop; the newer the snapshot, the faster it depreciates. Third, lines of code are a cost, not a score. 340,000 lines of Rust means 340,000 lines somebody has to read, fix, and take responsibility for. The more code, the longer the maintenance bill — and Stenberg's line, "They spent their money and effort on that?", asked with puzzlement and a touch of amusement, is really asking whether that bill was worth paying.

To be fair to the rewriters, Stenberg does not deny the value of what they did. He closes with: "I'm amused. A little puzzled. Fascinated." He also makes a point of saying he has not been in contact with any of the people behind the rewrites and does not know what they will do with the projects going forward: "Are they anything more than proof of concepts? I presume we will find out." If the rewriters go on to build their own tests, user base, and maintenance rhythm, and keep tracking curl's daily commits, this story could still reverse. The only conclusion available today is: the first version is written, and that is remarkable; but the software race was never about who writes the first version first.

If you are thinking of asking an agent to rewrite something, run through this checklist first

After reading this story, if you happen to have a "get the agent to rewrite the whole project" idea in mind, run through four questions first. One, is the specification complete: does your project have a specification that does not depend on anyone's head — a complete test suite, written API contracts, runnable use cases? If the tests were added afterwards and the docs were improvised, get the agent to fill in the tests and docs first, then talk about rewriting. Two, where are the users: after the rewrite ships, who will use it, who will report bugs, who will tell you when it breaks? A rewrite with no users will not even notice that it has fallen behind. Three, who maintains it: on the day the rewrite is finished, who is responsible for tracking upstream commits every day and fixing newly appearing bugs? If the answer is "we'll figure it out later", what you have is not a new project but a snapshot with a three-month expiry date. Four, why rewrite at all: is it to eliminate a specific, real class of errors, or just because "Rust is more modern" and "a rewrite sounds cool"? Stenberg's 17.3% is a reminder: switching languages solves only a small part of the problem, and the other 82.7% is still waiting for you, before and after the rewrite.

There is also a more pragmatic approach, visible between the lines of Stenberg's post: do not start by rewriting the whole project. First let the agent fix bugs, add tests, and do small refactors inside the original project — work with a built-in feedback loop, where you can tell immediately whether it was done well. Once it has proven its understanding of the project's specification on small tasks, then consider the big surgery. In the curl story, the agents' most impressive result came precisely from a "there is an answer key to copy" translation task; put them on a creation task with no answer key, and the report card could look completely different. Telling those two kinds of task apart is the first step to using agents well.

Conclusion: the first version was never the finish line

185,000 lines of C became 340,000 lines of Rust, 8,600 dollars, a little more than three weeks — those figures are themselves a public demonstration of what AI coding can do, and they deserve to be taken seriously. But Stenberg's response is a reminder that a demonstration and a product are separated by a river: on this side is "written", on the other side is "alive". curl has lived for 25 years not because some version was written fast, but because of 11 commits a day, more than 200 bug fixes a year, 81 vulnerabilities found and fixed, and a crowd of users willing to keep pointing out what is wrong. Agents have just proven they can translate a finished project into another language; they have not yet proven they can replace the community that keeps a project alive. For people who vibe-code, that is the line most worth taking away: do not only ask how fast an agent can write — ask who will keep what it wrote alive afterwards.

The next time you see a headline about agents rewriting some project in three weeks, ask three questions first: was it a translation task or a creation task? How many new commits is the original project still growing by each day? And are the rewriters ready to be maintainers? The answers to those three questions will tell you more than the line count and the dollar figure — whether this rewrite is a demonstration, or the beginning of a new project. Stenberg has already given his answer: getting it written is only the start; staying alive is the real exam for software.

Views 0Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality
Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted
News
One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Developer WorkflowProduct LaunchModel Updates