This week the Hacker News front page handed 314 points and 273 comments to an essay on the blog unsung.aresluna.org, titled “On caring for user data: NeoVim caused Vim undo files to be deleted.” The URL slug files the verdict for you: they had no concept of a duty of care to their users. Two text editors, one shared convention for keeping undo history on disk, and one of them apparently treating the other’s files as refuse. I’ll take the essay’s account at face value — the argument below doesn’t turn on the mechanism.
The comment thread is having the wrong fight. So, largely, is the essay.
The Volunteer Defense Stops at the Delete Key
The first move in any thread like this is the free-labor defense: Neovim is maintained by volunteers, nobody pays them, you are entitled to nothing. That argument is coherent when the complaint is a missing feature or an unloved parser. It stops being coherent at a destructive filesystem operation on files the program did not create.
Nobody asked Neovim to be faster. They asked it not to reach into a directory and remove something.
And look at what the defense is actually protecting — not a company, not a product, not even a person. A convention. Vim and Neovim agreed, without ever agreeing, that undo history lives in a hidden file beside the file it describes, in a format neither project publishes a specification for. The spec is whatever the other team’s source code happens to do this month. Compatibility between the two is maintained by people reading each other’s patches and hoping.
Nobody Holds a Deed to a Dotfile
Here is the architectural sin, and it long predates both editors. Your home directory is treated as a commons by every tool you install. That undo file sits in your namespace, on your disk, inside your backups. It looks like your data. It isn’t — only one program can read it. But it isn’t really the program’s data either, or it would live in the program’s own cache directory, versioned, namespaced, and quietly disposable.
So it is property without a deed. If the undo file were yours, there would be a published format and a documented way to move it between machines. If it were the editor’s, it wouldn’t be squatting next to chapter-draft.md. It is neither, which is why a bug in one program becomes data loss in another, and why the party holding the loss has nobody to call. Your backups faithfully preserve a cache you cannot read and a loss you cannot detect until the moment you reach for undo.
That is not a duty-of-care failure. It is a governance failure wearing one as a costume.
A Public Trust With an All-Caps Disclaimer
Now the part that should make the ecosystem’s friends flinch. The standard free-software license disclaims every warranty in capital letters, because the law requires shouting to make an abdication stick. Read the disclaimer and you will find that the entire risk as to the quality and performance of the program rests with you.
Fine, as far as it goes. But you cannot simultaneously market yourself as the trustworthy option — inspect the code, own your tools, escape the vendor — and then, when the code deletes something, retreat behind a document that says AS IS in the largest font on the page. It is a public trust with the legal posture of a gift, and each posture gets selected for whichever is convenient that afternoon.
Enterprises worked this out years ago. They don’t rely on care; they buy support contracts, which are the one place in this ecosystem where a duty is written down, priced, and enforceable. As a support engineer at one of those vendors put it in a Slack message to me: “We sell the warranty the license spends four paragraphs disclaiming. That’s the whole product.”
Anyone on the right who likes the phrase “you agreed to the license” should follow it to its conclusion: if the license is the whole moral universe, then caring for user data is not a duty at all — it is a marketing claim, and the honest remedy is a contract. You don’t get to oppose software-liability regimes in one breath and plead a moral obligation to somebody’s undo history in the next.
Name Your Cache Like a Guest
The fix is cheaper than a regulator and less romantic than a movement. Stop writing private bookkeeping into the user’s namespace under a name that reads like their own material. Give each tool one documented store, version the format, publish a page describing it. If you intend to interoperate with a competing editor, write down the format you are interoperating with — a file format with two implementations and no document is a landmine with a maintenance schedule.
None of that requires anyone to be nicer. It requires someone to be accountable, which is a different and considerably more expensive thing.
The next time this happens — and it will be some other tool, some other hidden file — another 273 comments will be spent on the same argument about volunteer labor, and the duty of care will still exist only in a blog post’s slug.