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 when real networks misbehave. A rewrite frozen at import time does not receive those reports unless a team replays upstream history daily—something Stenberg says averages ~11 commits per day.
-
ABI and API stability are the moat. Only curl can show decades of libcurl compatibility. A day-old Rust tarball might compile; it cannot yet prove multi-year integrator trust.
-
Memory safety is partial protection. Stenberg repeats his 2026 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, plan incremental parity tests—see recorded parity MCP patterns—not a big-bang repo swap.
- Track CVE closure rate, not LOC 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 and ABI 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 and 200+ 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 would create 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 vulnerabilities confirmed in 2026 through his November tally
- 14 plausibly memory-safety class in C
- 67 would remain in a hypothetical 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 and thousands of apps depending on stable ABIs
- ~11 commits/day long-run average
- Bug reports from real users when CDNs change headers or corporate 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 ignore review backlog |
| Cap rewrite spend without merge plan | $8k of tokens ≠ five years of maintainer time |
| Run parity suites on every protocol you actually use | Translation passes unit tests, fails integration 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.
- GitHub MDASH: 9,791 flags to 99 reports
- External sandboxes for coding agents
- Rust Anything incremental rewrite MCP
- Brotli CVE beyond Node and curl
- Claude Code team code review risks
Quotes and counts follow Daniel Stenberg's November 18, 2026 daniel.haxx.se post and Simon Willison's relay.
