cd /news/ai-agents/daniel-stenberg-agentic-rust-curl-re… · home › topics › ai-agents › article
[ARTICLE · art-171949] src=explainx.ai ↗ pub= topic=ai-agents verified=true sentiment=↓ negative

Daniel Stenberg: Agentic Rust curl Rewrites Cannot Keep Up With Real curl

Curl maintainer Daniel Stenberg reported in a November 2026 blog post that coding agents converted 185,000 lines of C into 340,000 lines of Rust in a few weeks, while upstream curl shipped more than 300 commits and roughly 200 bugfixes in about three weeks that the agent-generated rewrites never absorbed. Stenberg cited his 2026 scorecard finding that only 14 of 81 confirmed curl vulnerabilities (about 17.3%) might have been avoided in Rust, with 67 remaining, and noted a November "curl in Rust" project spent about $8,600 in agent compute. Stenberg also described curl's OSS Scanner enrollment, where a November 5 mail cited 45 vulnerabilities, maintainers confirmed five and reclassified many as bugs, an 11% confirm rate he framed as a human-triage workflow warning rather than an anti-AI verdict.

recommendation

When agents rewrite or port a maintained library, wire them to replay upstream commits and bugfixes continuously instead of one-shot translation, and route AI-generated vulnerability reports through human triage before patching.

more in playbook: Working with AI coding agents
by read7 min views2 publishedNov 18, 2026
Daniel Stenberg: Agentic Rust curl Rewrites Cannot Keep Up With Real curl
Image: Explainx (auto-discovered)

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 #

  1. Contribute upstream when agents find real issues; do not fork silently.
  2. If you migrate languages , planincremental parity tests —seerecorded parity MCP patterns —not a big-bang repo swap.
  3. Track CVE closure rate , notLOC generated .
  4. 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.

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.

── more in #ai-agents 4 stories · sorted by recency
── more on @daniel stenberg 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/daniel-stenberg-agen…] indexed:0 read:7min 2026-11-18 · —