While coding agents published Rust rewrites of curl, Daniel Stenberg counts more than 300 upstream commits and roughly 200 bugfixes those clones never absorbed. In a November 2026 post on daniel.haxx.se—quoted the same day by Simon Willison—the curl maintainer says agents turned 185,000 lines of C into 340,000 lines of Rust in a few weeks, yet curl itself kept shipping vulnerability and bug work agents cannot mirror from a snapshot.
For anyone using Claude Code, Codex, or Copilot on legacy infrastructure code, the post is a maintenance lecture, not a language war. Stenberg already documents Anthropic OSS Scanner findings on curl in parallel with GitHub's MDASH maintainer reports; the Rust rewrite story asks a different question: can agents operate a multi-decade ABI-stable library, not just translate it once?
What Stenberg measured #
Open box with flame linking to chips, evoking agent-generated forks that skip upstream maintenance
The core contrast is velocity, not syntax:
| Window (per Stenberg) | curl upstream | Agent Rust rewrites |
|---|---|---|
| ~3 weeks | 300+ merges ,200+ bugfixes ,vulnerability fixes | Static translation from a point-in-time tree |
| Line count | Continuing C evolution | 185k → 340k Rust lines claimed |
Stenberg names urlx earlier in the fall and a November "curl in Rust" project spending about $8,600 in agent compute, per the rewrite authors' marketing. He notes AIs trained on curl's docs, tests, and decade of issues—translation is easier because the specification is public, not because agents discovered protocols.
Why one-shot rewrites miss the point #
Stenberg's argument chains three ideas explainx.ai has seen across external sandboxes for coding agents and Rust incremental rewrite tooling:
curl is a time series. Users file bugs whenreal networks misbehave. A rewrite frozen at import timedoes not receive those reports unless a teamreplays upstream history daily—something Stenberg says averages**~11 commits per day** . 2. ABI and API stability are the moat. Only curl can showdecades oflibcurl compatibility. A day-old Rust tarballmight compile ; it cannot yet provemulti-year integrator trust. 3. Memory safety is partial protection. Stenberg repeats his2026 scorecard :14 of 81 confirmed vulnerabilities (~17.3% ) might have been avoided in Rust;67 would still exist. That aligns with**Brotli CVE fallout across runtimes** —logic bugs survive language choice.
OSS Scanner versus maintainer reality #
Branch path reaching past a closed gate, evoking maintainer triage before AI severity labels ship
Stenberg's blog from early November walks through OSS Scanner enrollment after Max Dymond's PR. The November 5 mail cited 45 vulnerabilities; maintainers confirmed five, reclassified many as bugs, and called one report backwards—patching would introduce the flaw the AI alleged.
That 11% vulnerability confirm rate is not an anti-AI dunk. It is a workflow warning: long AI reports still need human triage, the same bottleneck Microsoft MDASH tried to ease with private reports plus suggested fixes.
What builders should do #
- Contribute upstream when agents find real issues; do not fork silently.
- If you migrate languages , planincremental parity tests —seerecorded parity MCP patterns —not a big-bang repo swap.
- Track CVE closure rate , notLOC generated .
- For HTTP stacks in agents , remember**curl underpins countless tools** ; breaking compatibility has ecosystem blast radius.
The November rewrite wave in context #
Stenberg is not reacting to a single repo. His November 18 essay sits in a month where multiple agent-driven curl-alikes marketed memory safety and modern Rust ergonomics while libcurl consumers—PHP, Git, Python requests stacks, CI pipelines—kept filing protocol edge cases only visible at Internet scale.
| Project shape (per Stenberg) | Claim | Maintainer counterpoint |
|---|---|---|
| urlx (fall 2026) | From-scratch memory-safe curl/libcurl | Must rebuild trust andABI from zero |
| "curl in Rust" (Nov 2026) | ~ $8,600 agent spend; same branding as upstream | Name collision confuses integrators |
| curl upstream | Still C | 300+ commits and200+ fixes in the measured window |
The 340k Rust lines versus 185k C lines stat is meant to puncture "Rust is leaner" marketing. More lines can mean more generated boilerplate, not more capability. Without continuous merges, those lines are decorative.
OSS Scanner: what the 45-report tarball contained #
Stenberg's earlier November write-up is part of the same argument. After enrollment, Anthropic OSS Scanner emailed 45 alleged vulnerabilities and 23 ordinary bugs in one tarball. Maintainers translated each into GitHub issues under their ASSESS → severity workflow.
Outcomes he reported:
- 1 MEDIUM → LOW after review
- 44 LOW allegations → mostly bugs or NONE
- 5 confirmed vulnerabilities (11.1%)
- 1 completely inverted report that wouldcreate a flaw if applied blindly
He also complains about report length—a familiar AI-writing pattern—and notes 11 issues still open at the time of writing. That is the same maintainer labor problem Harvard's code-review bottleneck research describes for human teams, amplified when every alert looks like CVE theater.
Positive read: OSS Scanner found real flaws curl might have missed without another pair of eyes. Negative read: severity inflation burns senior maintainer weeks. GitHub MDASH tried the opposite design—private maintainer reports with patches—because raw alert floods do not merge themselves.
Memory safety math Stenberg wants you to repeat #
Stenberg's 17.3% figure is worth quoting precisely because CTOs use it wrongly in rewrite business cases:
- 81 curl vulnerabilitiesconfirmed in 2026 through his November tally
- 14 plausiblymemory-safety class in C
- 67 would remain in ahypothetical Rust curl
Logic bugs—parsing mistakes, state-machine errors, protocol misunderstandings—dominate. Agents excel at translating syntax; they do not automatically preserve thirty years of negotiated behavior around TLS fingerprints, HTTP/2 push, FTP weirdness, or proxy auth chains.
If your platform mandates Rust for new code, Stenberg's point is still: refactor hot paths, fuzz continuously, and keep one canonical library—do not ask users to relink against unmaintained forks.
Curl's moat is social, not syntactic #
Stenberg's 30-year anniversary posts (linked from the same blog index) emphasize community velocity:
- Hundreds of test cases andthousands of apps depending onstable ABIs
- ~11 commits/day long-run average
- Bug reports from real users whenCDNs change headers orcorporate proxies break CONNECT
Agent rewrites inherit none of that feedback loop unless operators pay for permanent merge staff. That is why he ends amused but puzzled: flattery through imitation does not pay maintainer salaries.
Agent workflow lessons for HTTP clients in 2026 #
Teams wiring coding agents into network stacks should translate Stenberg into policy:
| Policy | Rationale |
|---|---|
| Ban silent libcurl swaps | ABI breaks PHP, Git, CI without loud versioning |
| Require upstream issue links for agent patches | Prevents drive-by PRs that ignorereview backlog |
| Cap rewrite spend withoutmerge plan | $8k of tokens ≠ five years of maintainer time |
| Run parity suites onevery protocol you actually use | Translation passes unit tests , failsintegration fog |
Pair with Phonebox desk agents and Soduwork multi-harness workspaces only after network libraries have owners, not forks.
Thirty-year lineage in one paragraph #
Stenberg's blog index still tells httpget → urlget → curl history: Rafael Sagula's 1996 httpget, Daniel's maintainer takeover, gopher and FTP additions, libcurl in 2000, PHP adoption, git's use of libcurl for remotes. Agent rewrites skip that institutional memory. Readers learning why curl wins should start with time and trust, not language fashion.
When Simon Willison relayed the quote, his audience—agent builders—got the memo: translation demos are not operations.
Search answers: should you replace libcurl with a Rust rewrite? #
No for almost all production teams today. If you depend on distro packages, language bindings, or decade-old ABI promises, stay on upstream libcurl and send patches. Consider Rust microservices only where you own the full lifecycle and can fund merges forever.
When might a rewrite be rational? Greenfield closed binaries with no third-party libcurl consumers, no need for PHP/Git compatibility, and a budget line for permanent parity CI—rare in practice.
Does Anthropic OSS Scanner replace human review? Stenberg's numbers say no: interesting signal, low confirm rate on CVE labels, heavy triage. Use it like MDASH private reports—a feeder, not an owner.
What should security teams tell developers? Block shadow curl forks in dependency scanners; require CVE tracking against curl.se advisories, not GitHub fork stars.
Will Rust eliminate supply-chain risk? No—typosquat on PyPI-style attacks target package names, not languages. Pin official curl builds and teach agents not to suggest alternate curl binaries from random repos.
Bottom line: Stenberg is not anti-Rust. He is anti-fiction that a November tarball replaces a living project. Measure agents on issues closed upstream, not lines emitted sideways.
Related reading #
Reading gets you the idea. Building it with feedback gets you the skill.
Quotes and counts follow Daniel Stenberg's November 18, 2026 daniel.haxx.se post and Simon Willison's relay.