I've been using Vim daily for 13 years and switched to NeoVim about a year of two ago. For me the main advantages over Vim are just the Lua scripting instead of Vimscript, its support for language servers, and better handling of terminals windows running inside Vim.

However, I do still run visual studio in parallel for debugging. It's basically essential when dealing with console game development.

I use neovim daily but am 100% sure I'm not even scratching the surface of its power. In fact I'm not even sure I'm using anything specific to the "neo" variant vs plain vim.

I can do simple search/replace, page up/down, jump to character or delete x words, but I feel like I'm missing a lot to really take advantage of it.

Is there a tutorial or guide people recommend to become more of a power user? The only plugin I have is the Markdown editor for instance.

Ok, this sounds awesome, but do you miss the GUI integrations? like , being able to pop a document open in your editor from the desktop?

It just feels like it's hard to nail down your preferred workflow / setup ... but it's likely worth it if you're using it daily!

Are there any good visual or video demos of using this type of setup? I'm having trouble picturing what makes people really love this type of TUI-only workflow.

Sounds awesome. Can you tell us more... How do you ideally use/setup AI,tmux and nvim?

How many weird terminal bugs do you have in your setup? Eg one that annoys me the most is that pressing esc in insert mode often takes a few seconds to do its thing.

Use windows and leave kernel panics behind :)

i can tell you dont actually SSH often by tbe way. Also, tmux doesnt magically reduce resource requirements of your applications

As others have said, the fact that they're letting the ecosystem settle before including something out-of-the box is beneficial in some sense. It's allowed time for experiments (including my own "how would I do UI in Neovim: morph.nvim [1]").

For some, this stage of a project attracts tinkerers and builders, and lets the community shape how things are done in the future. It's not always practical, but it does have a certain appeal.

[1] https://github.com/jrop/morph.nvim

I agree in principle that absorbing the best from the ecosystem is good. However, anything pulled into core should have a long lifetime and be considered part of the API. This deserves careful consideration, and plugins work really well until it is clear there is a reason to pull something in.

This is what happened with the Language Server Protocol.

Prior to 0.9 (if I recall correctly), you had to install a plugin to be able to interface with LSP servers, and in 0.9 they integrated the support into NeoVim itself.

There are lot of readymade neovim configs you can copy. I was experimenting recently with lazy.vim and took a git clone and cp command to get up and running

I believe neovim started as a fork specifically to implement features like LSP support and package management, VIM eventually also caught up. But i don't believe anything is out of the table, or against Vim tradition. Which features do you want to see built-in, specifically?

Which is why I just went with Helix and learned their keybindings. I have much more important things to do than figuring out why a plugin stopped working.

Neovim is actively moving in that direction.

Define “modern”!

Almost all such complaints are close to “I want to be cool and be seen as an haxor, but all I know is a bit of VSCode and IDEA, make it easier for me, plz”.

Multi cursor support in VSCode replaced 98% of my need for macros. Yes, macros are more powerful, but they are pretty easy to get wrong. With multiple cursors, it's far easier to spot where your inputs don't work out and adjust accordingly.

Multi cursor is the feature that increased my productivity the most across the board.

Kakoune has replaced many features with multicursor, including the sed-like commands (where you just select an area, search for patterns inside it to create the multiple cursors, then perform regular edits (which also means you can perform much more complex than simple replaces). It is really useful for refactors, e.g. even if you don't have any LSP (e.g. for plain text) you can easily rename symbols, reorder/select in log files, etc

I'm not sure how people typically use neovim, but in Zed I find multiple cursors (especially combined with multiple file buffers) extremely ergonomic for refactoring quickly and easily where tools like find and replace or simple renaming doesn't suffice. It lets you scan through and add cursors where you need them, then perform your edits across locations and even files all at once. It's so nice that it played a significant role in me keeping Zed early on despite it missing a lot of extensions I used in VS Code.

Looking forward to multiple cursors… but Vim/Neovim can already do some of the common use-cases for multiple cursors, like prepending (or appending) text to a bunch of lines using visual block mode [1].

Here’s a video example [2]:

[1]: https://neovim.io/doc/user/usr_10/#_visual-block-mode

[2]: https://www.reddit.com/r/vim/comments/jai57c/the_usefulness_...

You'd do text editing with it with the coolest feedback loop - immediately seeing the changes and what those changes apply to beforehand, that's different from having to repeat some macro multiple times

Helix editor is based around that. Better than vim default imo

Really excited about this! At least in Sublime Text I've found multiple cursors a really powerful tool for ad-hoc transformations on snippets of semi-structured text or instantly and visually applying the same edit on multiple similar lines.

Any chance regular vim will some day get multiple cursors? That's the one thing I miss.

Whats with all the fuss over multicursor. How is this different from just using '.'

"Image API: vim.ui.img"

Oh neat!

Multiple cursors were the killer feature that got me to start using Sublime Text back in ~2010. Still an absolute staple of my text editing toolbox. Ctrl-D Ctrl-D Ctrl-D ...

Lookup helix tutorial. It’s pretty useful.

one cursor for you one cursor for claude code :)

It's funny because I miss this one all the time. I got use it in Sublime and VScode before making the jump to Neovim. I know you can get similar functionality from macros and what not, but it's just not the same.

LLMs: Look, I can write code! neovim users: hold my beer, multicursor is here!

I switched from Cursor to Neovim and at first I hated Neovim’s poor AI ghost text. Now I kind of like the break from heavy AI when I write code.

The vast vast majority of my code is written by Claude Code, so I don’t write much. But when I do it’s like an exercise in warding off programming atrophy

Have a look here. This is incredible guide to the `vim.pack`.

https://echasnovski.com/blog/2026-03-13-a-guide-to-vim-pack....

I'm assuming there will be something like lazy.nvim built on top of vim.pack. Some of the conventions might go away (ie constantly calling `.setup`).

> how verbose it turned out

Verbose? The new plugin manager's interface is literature just vim.pack.add({url}), not sure what is verbose about that

I always thought Vim/Nvim already had a built-in package manager, git clone inside ~/.vim/pack/*/start, am I missing anything by not using a "real" package manager?

It being built in sounds nice, although I have some lines in my config that automatically install lazy if it’s missing.

Tried to switch but found lazy.nvim better

Sidekick.nvim is nice, you get a "real" terminal window on the side with many different agents to choose from.

Either opencode, claude, gemini, copilot, basically most that are relevant :D

Its a pretty light connection-layer, so it helps with sending context.

Ghostty split panes - coding TUI in one pane, neovim in the other, maybe a third pane for shell.

Just use this; it's literally claude code in a terminal tab in vim; also aware of what files are open in vim.

https://github.com/coder/claudecode.nvim

I just run them in separate terminals. The only real gap was that I couldn't tell the robot to open files in nvim when I wanted to look at them, the way it could in other IDEs, so I whipped up a quick skill (https://github.com/mkozlows/nvim-skill) to do that.

Check out avante.nvim: https://github.com/yetone/avante.nvim

Am I misremembering cause I could have sworn that Aider started out as a nvim plugin?? https://github.com/Aider-AI/aider

Mentioned elsewhere, but

:term claude

In a split goes a long way for me!

Just open a terminal split/tab and use claude there. The neovim buffer will update real-time.

Yes tab split, neovim on the left, companion on the right, or different tabs. The plugin codecompanion.nvim is also great. I use it for common tasks. Like:

vaf (visual around function) <space>ad (leader key add docstring).

And it documents the functions with my system prompt instructions for what good docstings should look like.

Use no plugins, install Zellij (or tmux) and use in split panes, works great.

CodeCompanion.nvim is a pretty nice plugin. I use that for quick stuff and opencode in the embedded terminal for larger tasks.

I just have vim open in one terminal tab and Claude Code open in another terminal tab. Works great.

There is a roadmap and github issue tracking what is needed for 1.0.

https://github.com/neovim/neovim/issues/20451

https://neovim.io/roadmap/

Possibly never: https://0ver.org/

Maybe when `:!` works the way vi does and POSIX says it must.

Just kidding, that will never happen.

AFAIK it's mostly about stabilizing the RPC API and Lua stdlib:

https://github.com/neovim/neovim/issues/20451

I had the same issue with LSPs. If you have LSP configurations in a dedicated lsp directory all you need to do is instead of calling this:

vim.lsp.config(<lsp server>, config)

just return the config as a table i.e

vim.lsp.config("emmet_ls", { filetypes = { "html", "css", "sass", "scss", "less", "svelte", "gotmpl", }, })

will become

return { filetypes = { "html", "css", "sass", "scss", "less", "svelte", "gotmpl", }, }

in lsp/emmet_ls.lua - file name is very important btw

The lspconfig depreciation was a very painful upgrade for me too, as it seems to be very poorly documented; but ultimately it came down to moving all of the LSP server configuration to `vim.lsp.config` blocks, then calling `vim.lsp.enable` with all the servers I use.

I’m still not clear on what Mason is doing in my config after the switch but oh well.

I understand the annoyance, but my workflow for years has been running (n)vim in tmux. So I never need to run terminal commands from the editor, that’s what other tmux panes/windows are for.

What are you doing with ! that requires this? Some alternatives I can think of depending on the use case are ^Z or :term.

the thread here may be useful: https://news.ycombinator.com/item?id=47565813

Seems like you need an account just to try it.

Resist hypes and just use whatever you feel like. Torvalds uses a 40 year old EMACS implementation and that seems to be working for him.

I've been using VIM/NVIM on and off for a while and the one thing that made it stick for me over VSCode was LazyVim [1]. If you're missing out on something IDE like VSCode, but you love vim it's a great way to go (it can take some getting used to so hang in there). EDIT LazyVim is based off nvim by the way. If your more into videos to learn about something this is a good intro to it from Elijah Manor [2]. I have my dotfiles stored on github that I use on my different machines, and use gnu `stow` and `make` to build them and that gives me my specific lazyvim setup free and quickly after just downloading a few dependencies.

[1]: https://www.lazyvim.org/ [2]: https://youtu.be/N93cTbtLCIM

> Does NeoVim support Claude Code?

Why does it need to? Just open CC in another terminal window or tab. Or run it in a split inside vim, using `:term`.

Ymmv, but I have been very happy using classic vim’s “native claude support”

:term claude

It will also expand special characters so you can do something like

:term claude “refactor %”

And Claude starts work on your current file right away. Also your buffers will update with Claude’s edits!

If it's just using the keyboard that's holding you back from VSCode, you'll be pleased to know it has plenty of its own shortcuts, as well as a "VIM navigation" mode you can turn on.

I motivated my Cursor-colleagues to switch to tmux+nvim -- they don't use it all the time, but they enjoy the vibe. Claude is running on some tmux pans. Much nicer than VSCode!

Used neovim and neovide for the last week (also had FOMO) and while they’re good (no major gripes) I ended up going back to macvim.

Are there specific features you’re missing from vscode?

What's the FOMO caused by? Asking as a vim user starting to get FOMOOFOMO.

Most of the active development in the ecosystem is done for neovim these days. If you're using barebones vim then yea you probably won't see much difference, otherwise you have no choice

I switched from vim to neovim at the time when the former didn't support true color themes and limited colors annoyed me. neovim offered true color support in the terminal so I switched and stayed with neovim since.

One major difference is neovim allowing to use Lua for configuration and plugins. I find Lua to be neater than vimscript.

You can use vim key binding in vs code.

What are you getting FOMO over? Been using Neovim since it forked from Vim and I'm very happy with it.

Lua has been a big boon to advanced configuration and the plugin ecosystem and Neovim supports everything I'd want and more. LSP and treesitter for instance are still better handled by Neovim.

If you dislike Lua (I'm not a fan) I recommend Fennel, but either way it's much better than Vimscript.

As for Claude there are at least two Neovim plugins for it. I use one of them and it works well but I can't remember which.

If it's because VSCode has built in IDE features like LSP integration, I personally really like Helix. Keyboard based (although not the same movements as Vim/Nvim, it didn't take me long to switch), and it's got built in LSP integration/stuff just works out of the box.

Although no LLM support in the editor, I personally just run Claude Code in a separate terminal, but if you want AI in the editor you'll have to look elsewhere.

I did try Neovim with Copilot a while back, and Google shows a few NeoVim Claude Code plugins, so it's probable that if you want an LLM in your text editor, NeoVim might work :)

Use the Neovim extension for VScode. It requires you to have Neovim installed, but it works way better then the Vim extension since it passes commands to neovim instead of using emulation.

It doesn't necessarily mean they're going to migrate from C, building a C project is just so much nicer with Zig than fiddling around with CMake. You got people using it as a build system even for Go projects, especially if they're relying on CGo.

However, if you were entertaining the idea of slowly switching to Zig, the build system would be the place to start. Moving away from CMake is worth it even if you don't push it further.

But yeah, the C-Zig interop story is so good it's a no brainer if you want to "modernize" your C codebase, and you can do so incrementally instead of stopping the world for a rewrite.

> the only way to do this incrementally without the massive friction of a full rust rewrite

Any rewrite is massive friction, I’m sure probably meant port? The only annoyance with Rust ports is if you have to support varargs. Hopefully that will come to an end soon.

Couldn't disagree more. Why move away from solid, mature build systems to something relatively fringe like zig.

Sadly, this is the general trend with neovim in general: less focus on stability, more and more focus on shiny new things. If I didn't have an nvim config that I'm used to I would have switched to plain vim ages ago.

> The folke/lazy.nvim is the most used plugin manager at the time of this writing. And rightly so: it is very capable with lots of features. Ironically, this itself makes it not very suitable to be a part of Neovim as most of the features come with significant code and maintenance complexity. Plus the whole idea of treating lazy loading as the main goal of a plugin manager does not sit well with Neovim core team.

https://echasnovski.com/blog/2026-03-13-a-guide-to-vim-pack....

Reading the code. Sometimes I also try to race claude in another worktree.

some people still write code