From Vim to Zed: Is This the Ultimate Code Editor?

Zed has been a name flickering on my radar for a couple of years. Nearly two years ago, I found a blog post titled “From Vim to Zed.” Just another one, I thought. But the author was Thorston Ball, a PhD, compiler-builder, and a known figure in the Go and Vim communities. I was intrigued.

As I read, I was hooked. It felt like he was narrating my own journey, celebrating a decade-plus of using Vim, reading the same niche articles, and even hearing the familiar voices of Vim educators. Thorston mentioned learning from the greats, but then he pivoted to why he was moving to Zed. “Sure,” I thought, “you work there.” But he continued: modern, written in Rust, open-source, and most importantly, Vim-first.

I had to try it. But honestly, the appeal wasn’t immediate. Life moved on, and I returned to my comfortable Neovim setup. It seemed Thorston did too.

Then, a week after rereading the post, an invitation to Zed landed in my inbox. I shared my story and questioned if it was still relevant. The response was a simple “Yes.”

So, is Zed truly good enough to pull a decade-long Neovim user to a GUI-based editor? Is it really that fast? What about the supposed lack of extensions? Let’s find out.

What is Zed?

Zed is a cross-platform, open-source code editor built from scratch in Rust. It comes from the creators of Atom, the beloved editor that was sunsetted in 2022. Zed was announced a year later and subsequently open-sourced. With a significant $32 million investment led by Sequoia, you can bet it’s powered by a swarm of engineering talent.

Interestingly, the very first thing you see—the welcome screen—is a demonstration of the editor’s speed, specifically when shifting between open tabs. This editor was built and is marketed to capture the hearts of developers, and no one else. It’s praised by large teams and well-known figures, arriving with all the bells and whistles you’d expect, and some you wouldn’t.

First Impressions: The CLI and a Speed Test

Installation is straightforward. Once you open it, you’re prompted to install its CLI. Yes, Zed has its own command-line utility, a clear signal they’re serious about winning over terminal-dwellers like me. You can set Zed as your default editor, making it pop up for commands like kubectl edit. A fully configured Zed works out of the box, so you never have to retreat to another terminal editor.

The interface isn’t revolutionary, but it shouldn’t be. It has a clean, Vim-first aesthetic. But I had to be the nerd and test their speed claims.

I opened four tabs (or buffers). With Vim mode on, I used [b and ]b to cycle through them flawlessly. To make them loop, the shortcut is Command+Shift+].

Just for kicks, I had to check that in Neovim. I opened the same four files and added a quick mapping.

-- A quick mapping in Neovim to cycle buffers
vim.api.nvim_set_keymap('n', '<S-Tab>', ':bprevious<CR>', { noremap = true, silent = true })
vim.api.nvim_set_keymap('n', '<Tab>', ':bnext<CR>', { noremap = true, silent = true })

And yeah, Neovim is fast. But there’s a tiny feeling that Zed is just a hair quicker. Does it matter? Not really. Both are exceptionally fast.

The Core Experience: Shortcuts and VIM Mode

A few essential shortcuts to get started:

• Command+J hides the bottom dock, which can house the terminal or a debug console.
• Command+Shift+P opens the command palette, your gateway to everything: shortcuts, keymaps, and commands.

The settings are managed in a settings.json file located at ~/.config/zed/settings.json. This is a huge plus for anyone coming from a text-based configuration world. My Vim mode was already enabled, along with a Catppuccin theme.

The default Vim mode is astonishingly good. Having tried Vim emulation in VS Code and JetBrains years ago, Zed’s is by far the most impressive. It’s not a 100% Vim replacement, as Thorston noted, but it’s remarkably close.

• Diagnostics: [d and ]d jump to the next and previous diagnostic errors.
• Navigation: Standard gg and G work perfectly.
• Text Objects: They also work great. I can visually select around a function with vaf or change inside it with cif.

You’ll also notice AI-powered ghost text, courtesy of Zed’s self-trained model, which required no setup. There are also Git hints on hover, showing commit and PR details—again, fully operational out of the box.

My one immediate miss is a fuzzy finder like Telescope or FZF. Zed has an open issue for this, but in the meantime, Command+P opens a file search box. It’s not a true fuzzy finder, but it’s more helpful than navigating a file tree.

What about macros? Recording a macro to add a comment works. The jump list? Control+O and Control+I work as expected. Honestly, apart from a few minor things, I almost feel at home. And this is without installing a single plugin or porting any of my custom Vim configurations. It’s pretty wild.

Customizing Keymaps

Zed provides a keymap editor in the UI to manage all configurations. But what about my beloved jj escape sequence?

To set this up, you open the keymap file and define the context.

[
  {
    "context": "Editor && vim_mode == 'insert'",
    "bindings": {
      "j j": "vim::NormalBefore"
    }
  }
]

It took me a few restarts to figure out why it wasn’t working. Zed respects the space as a separator. So, j j signifies two separate key presses, not a simultaneous chord. Adding the space fixed it.

Navigating between split panes felt natural. I instinctively used my Neovim muscle memory: Ctrl+W followed by a motion key (h, j, k, l). It just worked. Splitting with Ctrl+W and s? That worked too. I swear I didn’t touch a single config file for this. Neovim users should feel right at home.

Could I port my entire Neovim keymap configuration? I probably wouldn’t have to. Most of it is already here. But for the custom bits, I could even ask an AI like Gemini to convert my Lua config into Zed’s JSON format, and it does an exceptional job. The Vim experience is so complete that even running a shell command with :! works.

Integrated Tooling: Git, AI, and Collaboration

Zed comes with its own Git integration. You can see changes, explore diffs, and commit. It’s nothing revolutionary, but it’s solid and expected. With AI, you can even generate commit messages.

Command+B toggles the left dock. With both docks hidden, you enter a clean, focused state. This brings us to Zed’s most raved-about feature: multi-cursor.

It’s not a new concept, but it works flawlessly by default with Control+D over a word. The cool part? It works across different files. While I still prefer Neovim’s contextual rename feature, the variety of default options in Zed is admirable. It begs the question: if you get a new machine for a couple of days, would you spend hours reconfiguring everything, or just use something that works out of the box?

The Power of Zeta and Integrated AI

Before diving into AI-assisted coding, it’s crucial to mention Zeta, Zed’s open-source prediction model available on Hugging Face. It powers the suggestions you see, and its two main benefits are:

1. Speed: It’s built and trained for rapid, smart predictions.
2. Cost: It’s free, at least while in beta.

AI is threaded through everything in Zed: helpers, agents, and even the terminal. It works by default, either inline or as a general assistant, all configured through the settings panel.

This leads to another critical feature: collaboration. Pair programming is a vital skill when working with AI, providing a second set of eyes on the code. In Zed, collaboration is built-in. Command+C opens the collab dock. You can sign in, join live channels, jump into public calls, or start private chats with teammates to share your screen and get input. It’s an incredibly significant and often overlooked feature.

Debugging and the Terminal

When you find a bug, you need serious tools. Zed’s debugger works similarly to other IDEs. Hit the bug icon, create a debug session, add breakpoints, and track the process. It comes with DAP (Debug Adapter Protocol) ready to go.

The integrated terminal is also excellent. But the standout feature is the small star that provides inline terminal AI help, reminiscent of Warp. Asking it to “run my Go project” translates it into the correct command.

The Agent Panel: Is This the End for Other AI IDEs?

The agent panel is your main gateway for interacting with LLMs. Zed offers a pro plan with hosted models, but it also supports “Bring Your Own Keys” (BYOK) for whatever plan you already have. It supports terminal agents like Claude, Gemini, and Codex.

Having used these CLIs to ship production features, I can say that Zed offers the Cursor experience in a much, much faster IDE—not an expensive VS Code fork. It takes in context, iterates over problems, and handles permissions. I see no reason to use any other so-called “agentic IDE” ever again.

Pricing and Final Thoughts

The pro plan is $10 a month, which includes unlimited predictions but limited token usage for general AI tasks. Beyond that, it’s the API list price plus 10%. The list of supported providers is extensive, including OpenRouter for more options. It’s also important to remember: Zed can be used for free without any AI features at all.

So, the million-dollar question: is this enough for me to switch?

Yes and no.

I’ve been paying for AI platforms for over a year. Zed has its drawbacks; it’s not Neovim, nor does it try to be. My Neovim setup isn’t going anywhere. But for the agent panel, the Warp-like terminal, the blazing-fast performance, and the on-par Vim support, Zed has earned a permanent spot on my machine. It definitely stays.