The Editor Wars Are Over. The Reading Wars Started.

Last Tuesday I opened Neovim at nine and closed it after one. Four hours. I pressed i twice.

The rest was j, k, Ctrl-d, /, gd, Ctrl-o, and a lot of sitting still. An agent had written a 380-line change across six files overnight. My job was to find out whether it was right. I threw away two files, kept three, and rewrote one function by hand because the agent had solved a problem we do not have.

My config loads forty-one plugins. Maybe six of them mattered that morning.

That was the day the joke stopped being a joke.

The half of my config that died

The snippet engine is dead. I have not expanded a snippet in more than a year and I only noticed when I went looking for something to cut.

Autopairs is still installed. I cannot tell you the last time it saved me a keystroke that mattered.

Abbreviations, dead. The completion source priority ordering I tuned for a week in 2023, dead, replaced by something that does not care what order my sources are in. The little leader bindings that scaffolded a class or a spec file. All of it, dead.

Every one of those is insert mode machinery.

What survived is the other list. Telescope. Treesitter text objects. gd, Ctrl-o, Ctrl-i. The quickfix list. :cdo. Diffview. Folds. %. }. Search with n and N until the shape of the thing finally shows up.

Not one of those produces a character. All of it is navigation. All of it is reading.

Normal mode is the reading mode. It always was. Vim boots into it, lives in it, and makes you ask permission before you are allowed to type. People called that unintuitive for thirty years. It was not unintuitive. It was early.

I spent fifteen years tuning the part of the editor I now barely enter.

The loop broke

The old loop was think, type, run, fix. Tight. Measured in minutes.

The new loop is describe, wait, read, keep or throw away. Loose. Sometimes an hour goes by before I touch a key that changes a file.

The waiting is the part nobody warned me about. Not because it is long. Because it broke the thing that made editing feel good, which was that the machine answered at the speed of my hands. Now it answers at the speed of a model and my hands have nothing to do.

So I filled the gap. Second buffer, second task, second agent running in a split. And that is exactly where it went wrong, because the review that came next was happening in a head that had context-switched four times in ten minutes.

The most useful change I made to my workflow this year involved no plugin at all. I stopped running two agents at once.

Read the admiration column, not the usage column

Stack Overflow asked 26,143 developers about their editors in 2025. Everyone quoted the usage numbers. VS Code at 75.9%. Notepad++ at 27.4%. IntelliJ at 27.1%. Vim at 24.3%. Cursor arriving on the list for the first time at 17.9%. Neovim at 14%. Claude Code at 9.7%. Zed at 7.3%.

Nobody quoted the other column. Admiration counts the people who used a tool and want to keep using it, which is a much harder thing to buy.

Neovim: 74.4%. Highest in the survey by twelve points. Then RustRover and VS Code at 62.6%, Rider at 60.8%, Vim at 59.3%, WebStorm at 59.1%, IntelliJ at 58.2%, Zed at 57%, Notepad++ at 54.7%, PyCharm at 52.9%.

Now the AI-native tools. Claude Code is the best of them at 52.5%. Cursor at 46.7%. Cline and Roo at 44.8%. Windsurf at 41.8%. Lovable at 36.6%. Bolt at 36.4%.

Thirteen conventional editors score higher than the best-liked AI-native tool in the survey.

Notepad++ beats every single one of them on both columns. A Windows quick-edit utility, more used than Cursor and better liked than Claude Code. Eclipse is the floor of the whole table at 32.9%, and Lovable and Bolt are within four points of Eclipse.

The highest-scoring editor with serious AI ambitions is Zed at 57%, and Zed is the one that decided not to own the agent. Hold that thought.

The editors that were right early and got laughed at

Emacs people solved this fifteen years ago and nobody listened. Magit is the best diff and staging interface anybody has ever built inside an editor, and it has been sitting there longer than most AI companies have existed. Stage a hunk, split it, discard half of it, read the whole change as a structure rather than a wall. That is a reading tool. It was treated as a niche curiosity by an industry that then went out and paid billions for products that do a worse version of it. Stack Overflow moved Emacs and Helix off the preset answer list in 2025 and into write-ins, so their numbers stopped being comparable. Emacs did not decline. It got delisted.

JetBrains spent twenty-five years building find usages, call hierarchies, structural search, and inspections while the rest of us made jokes about the splash screen and the RAM. Every one of those features is reading infrastructure. JetBrains then adopted the Agent Client Protocol across the entire suite and co-launched the shared agent registry with Zed in January 2026. On the merits, JetBrains is the best-positioned company in this entire story, and almost nobody is saying so because they are not a startup.

Helix made the most honest argument and got ignored. Modal editing, LSP and treesitter built into the binary, and a founding position that you should not have to configure anything. Twenty years of config culture, and the editor that said do not bother is a rounding error in the survey. We did not want a better default. We wanted a project.

The bottleneck moved and everybody can see it

Faros AI looked at telemetry from more than 10,000 developers across 1,255 teams. Developers using AI completed 21% more tasks and merged 98% more pull requests. Review time per pull request went up 91%.

Twice the code. Twice the wait.

One 2025 measurement puts senior engineers at 4.3 minutes reviewing an AI suggestion against 1.2 minutes for code a human wrote. METR found that 75% of the developers in its study read every line of AI-generated code. DORA surveyed nearly 5,000 professionals and found 90% adoption with a median of two hours a day spent working with these tools.

Then Cursor bought Graphite on December 19, 2025, for well above Graphite’s $290 million valuation. Michael Truell’s stated reason was that “reviewing code looks the same as it did three years ago,” and that review keeps taking a larger share of the week as writing takes less.

The company that made writing code fastest went out and bought a code review company.

Read that again.

This exact thing already happened once

2016. Microsoft publishes the Language Server Protocol. Before it, every editor built its own language support from scratch, and that was the moat. After it, one language server powered VS Code, Vim, Emacs, and Sublime at the same time.

That was supposed to be terrible for editors. It flattened the thing they competed on.

It was the best thing that ever happened to Neovim. A terminal editor from 2015 got IntelliJ-grade intelligence for the price of a config file, and the entire modern Neovim revival stands on that one decision.

Now watch 2025. Zed ships the Agent Client Protocol, modeled openly on LSP. Agents run as subprocesses, JSON-RPC over stdio, editor owns the interface, agent owns the logic. JetBrains adopts it across the whole IDE suite. The two of them launch a shared agent registry in January 2026. avante.nvim speaks it. Microsoft has standardized VS Code on MCP and has not committed.

Same movie, second showing.

The agent is being pulled out of the editor and turned into a process the editor talks to, which is why Zed scores 57% while owning none of the intelligence. The moat around AI-native editors is dissolving on roughly the same timeline as the moat around language-aware IDEs did, for the same structural reason.

Whatever you think Cursor’s product is, a good chunk of it becomes a protocol.

What the next editor competes on

Diff as a first-class object rather than a git plugin bolted to the side. The best diff experience in most editors today is worse than GitHub’s web view, which is embarrassing for a tool you live inside eight hours a day. Emacs has had the answer since before any of this.

Navigation through code you have never seen and did not write. Different problem from navigating code you wrote last month. JetBrains has a twenty-five year head start and does not seem to know it.

Provenance. Which agent, which run, which prompt, which instruction file produced this block. Blame tells you which human touched a line. It tells you nothing about which of the four agents on your team did, or what you told it to do.

Neovim 0.12 shipped in March 2026 with a built-in plugin manager and native insert mode completion. Both good. Both the last war. I upgraded on day one and I will keep upgrading, and the core team is still optimizing a mode I visit less every quarter.

The fun was load-bearing

Nobody learned vim motions because of a spreadsheet.

There is no study. Nobody has ever shown that Vim users ship more software than VS Code users, and we never checked, because checking was never the point. We did it because it was fun.

That matters more than it sounds. The fun is what made people go deep enough on their tools to become genuinely fluent in them, and fluency is the thing that turned out to be scarce. When an agent drops 380 lines in front of you, the only thing standing between that code and production is whether you understand the system well enough to know it is wrong. Nobody grinds through fifteen years of that on discipline. They do it because they liked it.

Take the enjoyment out of the craft and you remove the mechanism that produces the people worth hiring. That is the apprenticeship problem one level down, running inside a single person instead of an org chart.

Here is the part that hurts to type. Some of that config time was procrastination with excellent posture. Fun and avoidance felt identical from the inside. I have rewritten a statusline instead of writing a migration and told myself it was investment.

Both are true. It was partly wasted and it was still the engine.

I still press i. Just less.

The half of the editor that made me a typist is finished. The half that made me a reader is what I get paid for.

I liked the first half more.

Final Words

I would like to know if this matches your experience or contradicts it, especially if you left the terminal for an AI-native editor and found the enjoyment came back rather than went away. The post is only half an argument without the pushback.

You can find me on LinkedIn (linkedin.com/in/ivanturkovic), X (x.com/ithora), and Threads (threads.com/@ithora).

If you want to reach me directly, the contact page is at ivanturkovic.com/contact.

For hiring or fractional CTO inquiries, you can book a 30-minute call at cal.eu/ivan-turkovic/30min.

So tell me: when you open your editor tomorrow morning, is any part of it still fun, or did that quietly become something you used to do?