Bauhaus-style geometric illustration: a complex network on the left and a simpler matching system on the right, in black, red, yellow and blue.

Coding agents can now recreate enormous software projects in weeks. Daniel Stenberg, the creator of curl, has a rather uncomfortable question for them: can they maintain those projects for the next twenty years?

We've reached an interesting point in software development.

A team launches a few AI coding agents.

Gives them a substantial open-source repository.

Asks them to rewrite the whole thing in Rust.

And a few weeks later, they have hundreds of thousands of lines of code, passing tests, an impressive GitHub repository, and a technical achievement that would have sounded almost ridiculous not long ago.

Naturally, people are impressed.

I'm impressed too.

But I keep coming back to a question.

What exactly has been accomplished?

Because there is a difference between producing a new implementation of an existing program and creating a viable replacement for that program.

And that difference becomes particularly important when the original software is something as fundamental as curl.

On November 17, 2026, Daniel Stenberg, the creator and long-time maintainer of curl, published a post titled Actual curl rewrites in Rust.

He discussed two projects attempting to reimplement curl and libcurl in Rust with extensive assistance from coding agents.

His central argument was straightforward:

Writing code once was never the issue.

I think he's right.

But the implications go considerably further than a debate about C versus Rust.

They concern what AI has actually made cheaper, what remains expensive, and why the most important asset in a mature software project may not be its source code.

185,000 Lines of C, 340,000 Lines of Rust

Stenberg discusses two projects.

The first is urlx, which describes itself as a memory-safe Rust reimplementation of curl and libcurl.

The second is curl, rewritten in Rust, a project that attempts to recreate curl's functionality, including its command-line interface and the libcurl C ABI.

These are not simply toys containing a few HTTP requests.

Both projects make substantial compatibility claims.

The authors have used existing curl tests and documentation to guide development.

The second project describes a structured development process involving an inventory of curl's features, a compatibility test suite, documented divergences, and extensive agent-generated code.

That is a serious undertaking.

Stenberg counted approximately 185,000 lines of original C and 340,000 lines of generated Rust in the rewrite he examined.

The work took a little more than three weeks.

Just consider how strange that sounds.

A software project developed over decades can now be reproduced to a substantial degree in less than a month.

Not necessarily replaced.

Not necessarily matched in every important respect.

But reproduced well enough to make the exercise technically credible.

That is an extraordinary improvement in the ability to generate code.

It is also where the easy part of the story ends.

The Original Project Didn't Stop Moving

While the agents were rewriting curl, the actual curl project continued developing.

Stenberg reports that the maintainers merged more than 300 commits during those three weeks.

More than 200 were bug fixes.

Several security vulnerabilities were also addressed.

So by the time the rewrite reached its target, the target had already moved.

And it kept moving.

The new implementation is not merely competing with a codebase.

It is competing with a development process.

That distinction is the most important part of Stenberg's argument.

A mature software project is not a finished object.

It is a continuous sequence of decisions.

A user reports an unusual failure.

Someone reproduces it.

A maintainer investigates.

A patch is proposed.

Tests are updated.

The patch is reviewed.

An edge case is discovered.

The implementation changes again.

And all of this happens while other people are working on unrelated improvements.

The source code is a snapshot of that process.

It contains the decisions made up to a particular moment.

But it does not contain the future decisions required to keep the system working.

An AI agent can reproduce the snapshot.

The more difficult question is whether the new project can reproduce the process.

The Hidden Specification Is the World Outside the Repository

There is a reason curl is such an interesting target.

It is exceptionally well documented.

Its source code is available.

Its behaviour has been tested extensively.

Its APIs are used by a huge range of applications.

And the project has accumulated decades of experience dealing with the unpleasant details of transferring data across networks.

A coding agent has an unusually rich specification to work from.

It can read the C implementation.

Consult documentation.

Inspect tests.

Observe expected behaviour.

Run comparisons.

And iteratively change its Rust implementation until the results align.

But that is not equivalent to independently rediscovering all the engineering knowledge embodied in curl.

The agents are benefiting from an enormous body of prior work.

This does not diminish their technical achievement.

It tells us what the achievement actually depends upon.

The original implementation is serving as an executable specification.

And that specification is unusually complete because real people have spent decades improving it.

There is also a further complication.

Not every relevant requirement is written down.

Some live in users' expectations.

Some live in old scripts.

Some depend on operating-system behaviour.

Some emerge only under particular network conditions.

Some are the result of applications using the API in ways nobody originally anticipated.

An implementation can satisfy an impressive collection of documented tests and still encounter a surprising amount of undocumented reality.

This is true of most software.

For a project such as curl, the surface area is particularly large.

HTTP versions.

Proxies.

Authentication.

TLS backends.

DNS behaviour.

Certificates.

Redirects.

Connection reuse.

File transfers.

Operating-system differences.

Error handling.

And combinations of these features that somebody, somewhere, depends upon.

The difficult part is not merely implementing each feature.

It is preserving the interactions between them.

Including interactions that only become visible when something breaks.

Passing Tests Is an Achievement, Not a Guarantee

The Rust projects deserve credit for using curl's tests.

That is much better than producing a large codebase and declaring success because a few example requests work.

The urlx repository reports that 1,300 applicable curl tests pass in its evaluated subset.

The second rewrite reports extensive compatibility testing against the original C implementation across supported configurations.

These are meaningful results.

But they need to be interpreted carefully.

A passing test demonstrates that a particular implementation behaves as expected under the conditions exercised by that test.

It does not establish complete equivalence across every possible input, platform, and deployment environment.

This is especially relevant when the system being replicated has an enormous compatibility surface.

The tests are the product of years of bug reports and improvements.

They contain a great deal of valuable accumulated knowledge.

But a new implementation can introduce different failure modes.

Different memory layouts.

Different dependency behaviour.

Different concurrency assumptions.

Different error paths.

Different interactions with foreign-function interfaces.

And different performance characteristics under real workloads.

A test suite is one of the strongest resources a rewrite can inherit.

It is not a substitute for production history.

The more interesting question is not whether the rewrite passes the original tests today.

It is what happens when a customer reports a failure tomorrow that neither implementation has encountered before.

Who investigates?

Who decides whether the behaviour is a bug or a compatibility requirement?

Who adds the regression test?

Who ships the fix?

And who makes sure the same failure does not return six months later?

These questions cannot be answered by counting generated lines of code.

Compatibility Is a Promise You Have to Keep

One of curl's greatest strengths is its long history of API and ABI stability.

For a library such as libcurl, compatibility is not merely about producing the same output for the same input.

It includes preserving expectations that other software relies upon.

Function signatures.

Calling conventions.

Exported symbols.

Structure layouts.

Error codes.

Binary compatibility.

Behaviour under obscure combinations of options.

A developer using libcurl may never have read its source code.

Their application simply depends upon the library continuing to behave as expected.

And if that application has been running successfully for fifteen years, the developer probably doesn't want to discover that a replacement library has a more elegant architecture but slightly different behaviour.

This is where mature software becomes difficult to replace.

The original implementation has accumulated obligations.

Some are documented.

Some are effectively contractual.

Others exist because breaking them would cause real problems for users.

And every new release must respect those obligations while changing the software.

The Rust rewrites are attempting to reproduce that compatibility.

That is valuable.

But compatibility is not a certificate you receive after a successful test run.

It is a continuing promise.

And the value of that promise becomes visible only over time.

The Rust Question Is Real, but It Isn't the Whole Question

It would be a mistake to interpret Stenberg's argument as proof that Rust provides no meaningful advantage.

Memory safety matters.

Type systems matter.

The ability to prevent entire classes of defects before code runs matters.

Rust can offer substantial benefits in software that processes untrusted input, manages complex state, and operates close to system interfaces.

Curl is exactly the kind of software where those benefits deserve serious consideration.

But the advantage should be stated precisely.

Stenberg provides a useful figure.

Of 81 vulnerabilities confirmed in curl during 2026 up to the date of his article, he classified 14 as mistakes that probably would have been prevented by using a memory-safe language.

That is 17.3%.

An important result.

But not an argument that Rust would eliminate all security problems.

The remaining 67 vulnerabilities were not classified as mistakes directly preventable through memory safety.

They involved other kinds of defects.

And a Rust rewrite would not automatically prevent every logic error, protocol misunderstanding, authentication problem, or incorrect security assumption.

There's an additional nuance.

Those figures classify historical vulnerabilities.

They do not tell us exactly how many vulnerabilities an independently written Rust implementation would contain.

A rewrite might avoid some old defects.

It might introduce new ones.

Its type system might prevent certain errors outside the narrower memory-safety category.

And unsafe code or foreign dependencies could still expose it to additional risks.

So I wouldn't interpret the figure as a precise forecast.

The practical conclusion is simpler.

Rust changes the kinds of mistakes a system is likely to make. It does not remove the need to maintain the system correctly.

A language can make certain invalid states difficult or impossible to express.

It cannot guarantee that the intended behaviour was correct in the first place.

And that distinction is especially important when the intended behaviour has been refined over decades.

And Then I Remember GNU Coreutils

Every time I read about another ambitious rewrite in Rust, I remember the long-running effort to reimplement GNU Coreutils.

The commands are wonderfully familiar.

ls.

cp.

mv.

rm.

sort.

cat.

And dozens of others that Unix users barely think about.

How difficult could they be?

Print a directory listing.

Copy a file.

Remove a file.

Count some lines.

Surely modern programming languages can handle that.

Of course they can.

The problem is not implementing the obvious operation.

The problem is implementing everything that users, scripts, applications, and operating systems have come to expect around that operation.

GNU Coreutils is not simply a collection of small command-line programs.

It is part of the behavioural foundation of an enormous software ecosystem.

The uutils project has spent years creating Rust implementations intended to provide compatible alternatives.

Unlike the recent AI-generated curl projects, uutils is not merely a rapid rewrite experiment.

It is a long-running open-source project with its own maintainers, contributors, releases, and compatibility work.

And it has achieved something substantial.

Ubuntu began using Rust-based Coreutils as its default provider with version 25.10.

That is genuine adoption.

Not just a benchmark.

Not just a GitHub demonstration.

But the path to that adoption is precisely what makes the comparison interesting.

Rust Doesn't Make rm Automatically Safe

When Ubuntu prepared to ship Rust Coreutils in its 26.04 LTS release, the project went through a significant security review.

Canonical commissioned an independent audit by Zellic.

Across two audit rounds, 113 findings of varying severity were identified.

The uutils community worked on addressing them.

And Ubuntu chose to retain GNU implementations of several particularly sensitive utilities while remaining issues were investigated.

In Ubuntu 26.04 LTS, cp, mv, and rm continued using GNU Coreutils.

These were not random exceptions.

They concern operations where mistakes can have serious consequences.

Copying files.

Moving files.

Deleting files.

One important issue involved time-of-check-to-time-of-use vulnerabilities.

A program checks something about a filesystem object.

Then performs an operation.

But the filesystem can change between those two moments.

The program may act on a different object from the one it checked.

A memory-safe language does not automatically solve this problem.

It is a question of filesystem semantics, race conditions, and system-level behaviour.

Exactly the kind of problem that can survive a change of implementation language.

The experience also demonstrates how a rewrite becomes production-ready.

Through audits.

Bug reports.

Compatibility testing.

Careful deployment decisions.

Feedback from users.

And continuous maintenance.

Later releases continued addressing the problems. Ubuntu's current documentation describes the progression toward full Rust Coreutils coverage in 26.10.

That is not a story of Rust failing.

It is a story of a serious Rust project doing the difficult work required to become infrastructure.

Which is a much more valuable achievement than simply demonstrating that the programs can be written.

The Three Stages We Keep Confusing

I think many discussions about AI-generated software confuse three different achievements.

The first is implementation.

Can we produce a working program?

Coding agents have become extraordinarily good at this.

The second is compatibility.

Can the new program reproduce the required behaviour of an existing system under realistic conditions?

This is much harder.

It requires extensive tests, accurate specifications, and careful validation.

The third is sustained operation.

Can the new program remain reliable, secure, compatible, and useful as its environment changes?

This is where the real difficulty begins.

A successful implementation is not automatically compatible.

A compatible implementation is not automatically maintainable.

And a maintainable implementation is not automatically supported by an organisation capable of sustaining it for years.

These are different engineering problems.

They require different kinds of evidence.

A working demo proves something.

A successful compatibility suite proves something more.

But years of stable releases, timely security fixes, and real-world usage prove something that neither can establish in advance.

Time matters.

And not because old software possesses some mystical superiority.

It matters because continued operation reveals problems that were not visible at the beginning.

The software improves as those problems are discovered and addressed.

The organisation improves too.

Maintainers learn which changes are dangerous.

Users learn how to report failures.

Reviewers develop judgment about the architecture.

Release processes become more reliable.

And the community gradually accumulates knowledge that cannot be recovered by reading a source file once.

A Fork Can Copy Code, but Not a Community

This is the strongest part of Stenberg's argument.

The most difficult thing to reproduce is not the code.

It is the system of people and practices that keeps the code alive.

Curl has users who depend upon it.

Maintainers who understand its architecture.

Contributors who submit fixes.

Security processes.

Release procedures.

Test infrastructure.

Documentation.

And a long history of responding to real-world problems.

A new project can copy the source code.

It can inherit tests.

It can use agents to translate implementations.

It can reproduce APIs.

But it does not automatically inherit the social organisation that produced the original project's reliability.

That organisation matters because software maintenance is partly a process of deciding what deserves attention.

Which bug is critical?

Which compatibility issue affects important users?

Which feature should be supported?

Which feature should be rejected?

When is a change too risky to merge?

When should a release be delayed?

When should a vulnerability be disclosed?

These decisions are not merely coding tasks.

They involve responsibility.

Judgment.

Communication.

And sometimes the willingness to disappoint people who want a feature that would create long-term problems.

AI agents may increasingly assist with all of these activities.

But assistance is not the same as accountability.

Somebody still has to own the decision.

And somebody has to be there when the decision turns out to be wrong.

The Source Code Is Not the Moat

There is a broader economic implication here.

For a long time, reproducing a complex codebase was expensive.

That cost provided a certain amount of protection to established software projects.

Not absolute protection.

But enough to make building a competitor a substantial undertaking.

AI changes this.

If an agent can reproduce hundreds of thousands of lines in a few weeks, the cost of creating an alternative implementation falls dramatically.

That is genuinely disruptive.

But it does not follow that the entire competitive advantage of the original project disappears.

The advantage may move.

From implementation to maintenance.

From writing code to understanding user requirements.

From producing features to preserving compatibility.

From solving known problems to discovering unknown ones.

From possessing a repository to sustaining an ecosystem.

This is not unique to curl.

The same pattern could appear in databases, frameworks, developer tools, operating-system components, and enterprise applications.

A competitor may reproduce the visible feature set.

But the real product includes years of integration work, operational knowledge, support, documentation, and user trust.

AI can reduce the cost of building the initial alternative.

It does not automatically eliminate the cost of earning that trust.

And this is perhaps where the most interesting competition will occur.

Not between humans writing code and agents writing code.

But between organisations capable of maintaining complex systems with and without extensive AI assistance.

The Original Maintainers Can Use Agents Too

There is another part of the discussion that deserves attention.

The existing curl project is not required to continue developing at its historical speed.

Its maintainers can use AI too.

They can automate repetitive changes.

Improve test generation.

Analyse bug reports.

Investigate failures.

Assist with refactoring.

And potentially accelerate some of the work that currently consumes human time.

This means the competition is not necessarily between a traditional human-maintained project and an AI-powered rewrite.

It may become a competition between two AI-assisted development organisations.

One begins with decades of production experience.

The other begins with a new implementation and potentially different architectural advantages.

Both have access to increasingly capable development tools.

And both must respond to the same changing external environment.

The new project might eventually succeed.

Perhaps it offers meaningful safety improvements.

Perhaps it targets a narrower feature set and becomes easier to maintain.

Perhaps a different architecture makes certain classes of change simpler.

Perhaps it attracts a strong community.

Or perhaps it finds a market that values specific characteristics more than perfect compatibility with curl.

There are plausible reasons for an alternative implementation to exist.

The mistake is assuming that the speed of its initial creation is sufficient evidence of future superiority.

It isn't.

The interesting comparison begins after the first version ships.

The Maintenance Test

Suppose I wanted to evaluate one of these Rust rewrites seriously.

I would not begin by counting lines of code.

And I would not treat the number of passing tests as a complete measure of success.

I'd want to know what happens over the next year.

Does the project keep up with relevant security fixes?

How quickly does it respond to new vulnerability disclosures?

Does it maintain API and ABI compatibility across releases?

What happens when curl changes a protocol implementation or fixes a subtle interoperability bug?

Does the rewrite independently investigate those issues, or does it simply translate upstream patches?

Either strategy could be legitimate.

But the maintenance model should be clear.

I'd also want to know whether the new implementation develops its own reliable test infrastructure.

Whether its tests catch regressions specific to Rust.

Whether downstream users encounter unexpected behaviour.

Whether performance remains competitive under realistic workloads.

And whether the maintainers can sustain the release process once the excitement surrounding the initial rewrite has faded.

There is nothing wrong with using coding agents for maintenance.

Quite the opposite.

If the agents can reliably analyse upstream changes, update the Rust implementation, generate regression tests, and support timely security releases, that would be a meaningful engineering achievement.

But it needs to be demonstrated continuously.

The useful benchmark is not how many lines the agents can translate in a week.

It is whether the project remains dependable when the original implementation has moved on.

Maybe a Full Rewrite Is the Wrong Product

There is also a strategic question.

Why recreate all of curl?

Sometimes there are excellent reasons.

Perhaps you need a memory-safe implementation with compatible APIs.

Perhaps you want to explore a substantially different architecture.

Perhaps you require capabilities that are difficult to introduce into the existing project.

Or perhaps the exercise itself provides valuable research into what coding agents can accomplish.

All reasonable motivations.

But if the goal is to create a production alternative, complete replication may not be the best first step.

Curl's feature set is enormous.

And every additional feature creates another compatibility obligation.

A smaller project could target a particular subset of protocols.

Or a specific deployment environment.

Or an API with a different compatibility contract.

It could aim to become the best solution for a clearly defined use case rather than reproduce every historical behaviour of a mature general-purpose library.

Of course, that would make the headline less impressive.

"AI agents built a focused, memory-safe networking library with a carefully chosen feature set" does not sound quite as dramatic as "AI rewrote curl."

But it may describe a more sustainable engineering strategy.

The value of a new implementation should not be measured by how closely it resembles a famous old project.

It should be measured by what it enables users to do, how reliably it does that work, and whether the maintainers can continue improving it.

What AI Has Actually Changed

I don't think the correct conclusion is that AI rewrites are pointless.

The ability to recreate complex software quickly is important.

It makes experimentation cheaper.

It allows developers to test alternative architectures.

It reduces the cost of porting software to new environments.

It may allow small teams to maintain implementations that previously required much larger engineering resources.

And it could eventually make replacing certain legacy systems more practical.

These are meaningful advances.

But they don't eliminate the basic distinction between building software and maintaining software.

If anything, they make that distinction more important.

When creating the first version was expensive, the difficulty of implementation concealed many of the costs that followed.

Now that initial implementation is becoming cheaper, the remaining costs are easier to see.

Compatibility.

Security.

Maintenance.

Integration.

Testing.

Support.

Governance.

The ability to make decisions about future development.

These were always part of software engineering.

AI hasn't invented them.

It has simply made the first stage of the process dramatically less expensive.

And that changes which problems deserve our attention.

The Part AI Hasn't Rewritten Yet

Stenberg's article is not particularly long.

It doesn't need to be.

His argument comes from a simple observation.

While several agents were busy reproducing curl, the actual curl project was busy improving curl.

That is an important difference.

The clones demonstrate that a large existing implementation can now be recreated rapidly.

The original demonstrates what maintaining such an implementation actually involves.

And uutils Coreutils provides a useful example of what happens when a Rust replacement progresses beyond the demonstration stage.

It faces audits.

Compatibility issues.

Release decisions.

Production bugs.

And years of development.

Exactly the things that make software useful long after the original implementation has been written.

So I agree with Stenberg's central point.

Writing the code once was never the whole problem.

But I would extend it slightly.

AI has made reproducing software cheaper. The next challenge is making the responsibility for that software cheaper without making it weaker.

That is a much more interesting problem than translating C into Rust.

And it is probably where the next generation of coding agents will be judged.

Not by how many files they create.

Not by how many commits appear in an impressive development log.

Not even solely by how many tests they pass.

But by whether they help people operate complex, evolving systems reliably over time.

Perhaps the agents will eventually become extraordinarily good at that too.

I wouldn't bet against the possibility.

But a successful rewrite produced in three weeks is not yet evidence.

For now, the most useful question to ask after seeing another spectacular AI-generated repository is relatively simple.

Who is going to maintain it?

And what happens when something breaks next Tuesday?

Because that is when the demo ends.

And software engineering begins.

Sources

Cover illustration supplied by the author.

Keep reading

Explore the writing archive →

Stay in touch

More essays and updates on ABVX Substack.

Read and subscribe on Substack →