Drew DeVault's AI-Free Vim: Why It Matters for Open Source

Now I'll apply the humanizer skill to the text. Now let me create the draft rewrite, apply the audit, and produce the final version. Now let me write the actual humanized draft and final: Now let me do the anti-AI audit pass as required by the skill, then produce the final version:

What makes the draft still obviously AI-generated?

• Some sections still have three-item lists with a very tidy "One camp / A second camp / A third camp" parallel structure that reads like an AI organizing a debate
• "That group is larger than most tech media coverage would suggest" — slightly oracular/editorial, reads like an AI making a confident claim without evidence
• The closing section still has mild pacing-by-paragraph tidiness — each paragraph feels exactly the right length
• The "Key takeaways" section, while de-bolded-header-style, still reads like an AI summary with bullet points
• A few phrases like "that's a governance decision as much as a technical one" and "that same logic applies" feel like AI transition phrases

Now let me revise for the final version:

A Vim fork that says no to AI

Drew DeVault is building an AI-free Vim fork, and developers have had a lot to say about it. The project runs counter to two years of tooling vendors cramming AI assistants into every editor, IDE, and terminal they could reach. For many working developers, that's not a fringe position — it's the first serious institutional pushback they've seen.

---

Who DeVault is, and why it matters who's doing this

DeVault isn't a random blogger with a hot take. He founded SourceHut, one of the few credible alternatives to GitHub that's actually built around minimalism, transparency, and user freedom. He created the Hare programming language. He runs infrastructure for dozens of open-source projects and has been writing about software ethics for years — not in a vague "tech should be good" way, but specifically about what it means to build tools that don't surveil their users or phone home to a vendor's API.

His blog has been a reference point for developers who care about software that does one thing well and doesn't need an internet connection to function. So when he forks Vim and explicitly commits to keeping AI out of it, that's not a stunt. It's a considered decision from someone who's spent a long time thinking about what open-source software is supposed to be for.

In a recent interview, DeVault laid out his reasons for the fork — a project explicitly committed to keeping AI features out of the codebase and out of the contribution pipeline.

---

What happened to the editor ecosystem

GitHub Copilot launched as a VS Code extension and became, fast, a baseline assumption. Neovim's plugin ecosystem filled up with AI completion tools. JetBrains baked AI Assistant into its IDEs. Tools that had no real reason to add AI features added them anyway, because the market pressure was enormous and the money was there. The question stopped being "should we add AI?" and started being "which AI vendor do we use?"

Vim was supposed to be immune to this, by reputation and by design. It's a modal editor with a forty-year lineage, valued precisely because it doesn't change without a good reason. But the ecosystem around it — plugins, distributions, adjacent forks — hasn't been immune. Neovim in particular became a popular target for AI plugin authors.

DeVault's fork is betting on a real constituency: developers who want their editor to be a tool, not a co-pilot. Developers who want to know what their editor is doing, who want their keystrokes to stay on their machine, and who don't want to audit a dependency tree just to find out whether some plugin is sending their code to a third-party API.

It's a bigger group than tech media coverage usually implies.

---

What "AI-free" actually commits to

The phrase sounds simple, but as a project policy it has real teeth.

At minimum, it means the project won't accept contributions that add AI-powered features — autocomplete, code generation, natural language interfaces, anything routing user input through a machine learning model. It probably means no dependencies on libraries whose primary purpose is AI inference. It may mean rejecting pull requests that introduce AI-adjacent telemetry, even indirectly.

That's a governance decision as much as a technical one. Open-source projects live and die by their contribution policies. A project that says "we won't merge AI features" is making a statement about what the software is for and who it serves. That statement attracts contributors who share the value and repels those who don't, and over time it shapes the project's culture as much as any line of code does.

There's precedent for this. Vim itself was historically conservative about features — Bram Moolenaar's stewardship was defined by a preference for stability and a high bar for new functionality. The difference now is that the pressure being resisted isn't just feature bloat; it's an entire industry paradigm.

An AI-free fork of Vim is a proof of concept: you can say no, maintain the fork, and build a community around the refusal.

---

AI skepticism in open source isn't one thing

It would be a mistake to treat DeVault's position as the only coherent response to AI in developer tooling. The disagreement doesn't break cleanly into two sides.

Some developers hold that AI doesn't belong in certain tools at all. Reasons vary: concerns about code laundering from training data, discomfort with dependence on proprietary model APIs, a belief that AI assistance erodes the craft of programming, or just a preference for tools that behave predictably.

Others accept AI but insist on control — on-device models, no data leaving the machine, no vendor lock-in. These are the developers running local inference with tools like Ollama, or small models on their own hardware. They want the productivity without the surveillance.

A third group has largely accepted the status quo: Copilot is fine, the productivity gains are real, the privacy tradeoffs are acceptable. This group is well-represented in the tech press and probably underrepresented in communities that have historically cared most about software freedom.

What DeVault's project does is give the first group something concrete. It also sharpens the question for the second: if you want AI in your tools but not at the cost of your data, what does that actually require? The answer has to involve either local inference or an extremely narrow, auditable integration — not a plugin calling out to a hosted API you don't control.

That same question shows up elsewhere. There's a real difference between AI that runs on your device and AI that routes your inputs through a vendor's infrastructure. Tools like LiveCue are built on that distinction — on-device processing, local context, no data leaving the machine.

---

What the fork signals

DeVault's AI-free Vim isn't going to replace Neovim or VS Code by adoption numbers. That's not the point.

The last decade of open source was shaped by the rise of GitHub, the normalization of corporate sponsorship, and the slow integration of SaaS dependencies into projects that once prided themselves on self-sufficiency. AI is the next wave of that pressure — more aggressive, because the tooling is more seductive and the vendor lock-in is harder to see until you're already in it.

A fork that explicitly refuses AI is a canary. If it attracts contributors and users, that tells you something real about demand that market surveys tend to miss. If it withers, that tells you something too.

The early signals — based on the response to DeVault's interview and the discussion it generated — suggest the canary is alive. A lot of developers feel the AI-in-everything trend has moved faster than the open-source community's ability to think carefully about what's being traded away. An AI-free Vim gives those developers somewhere to direct that energy.

---

Key takeaways

• DeVault's AI-free Vim fork is primarily a governance commitment — it defines what the project won't accept, not just what it does.
• The push to add AI to developer tools has been driven largely by commercial pressure, not community demand. Vim's ecosystem hasn't been immune.
• "AI-free" is a coherent position, not a reactionary one. It reflects real concerns about data routing, determinism, craft, and dependence on proprietary infrastructure.
• Open-source AI skepticism isn't monolithic. Some developers want no AI; others want AI that stays local and private. Both are pushback against the same underlying problem.
• The project's cultural signal may matter more than its adoption numbers. If it sustains a contributor community, it shows the market for AI-free tools is real.