Ask HN: How do you use Vim in the era of AI? | Hacker News Reader

Ask HN: How do you use Vim in the era of AI?

49 pointsrstagi99 comments

I'm a heavy vim user, but now that I look at the code less and less I'm wondering if it still makes sense.

How are you a heavy vim user if you wonder if vim makes sense with ai? There are so many things to do outside of writing code that vim is used for.

Also neovim + claude code + open terminal pane in tmux is the goated combo anyway. Especially more lately you need to understand the code you are writing if you want to do anything important in software, and the best way to do that is neovim :)

neovim + claude code + open terminal is exactly my setup! But all the heavy lifting I used to do simply I’m not doing it anymore. I spend most of the time creating new worktrees and reviewing code, and I guess I’m just not interested about the implementation details that much (not that I don’t look at the code, but minor styling things I just ignore them right now) I’m transitioning to this new way of work btw, so I still haven’t made up my mind. That’s why I asked for someone else opinion here :)

Why not opencode, that's one of the best claude code alternatives i have ever tried, but than of course it's your choice:

https://opencode.ai/

> neovim + claude + tmux is the goated combo

It absolutely is. I don't really understand why people still confine themselves to a full IDE when doing "agentic programming".

Especially with neovim with something like fzf or ctrl-p, which lets just quickly navigate codebases. This is about as far as you need to go. So to me, being terminal-first and being able to do multiple things at once makes more sense (hence tmux).

What exactly can you do with neovim tha I cannot do with vim? :-)

I wrote my own neovim AI harnesshttps://github.com/dlants/magenta.nvim

And wrote about my thoughts on the relevance of nvim here https://dlants.me/ai-whiplash.html

It's been many months, and I thoroughly prefer my harness inside of nvim as my day to day development environment. Using Claude code or cursor makes me feel very removed from the code.

Exploring code, gathering context and tweaking prompts/giving guidance to the agent are very much enhanced by neovim.

The biggest boon has been the fact that agents make customizing neovim a lot easier. Writing new bindings, config, and even building novel plugins.

Here's a few that I built that fit into my workflow:

- a tool for reviewing commits / branches / wip. https://github.com/dlants/glean

- an iterative grepper https://github.com/dlants/shuck

- a file picker that renders in your current window (like oil) and uses more intelligent signals for ranking (like frecency) https://github.com/dlants/needle

(Neo)vim is setup wonderfully for this era. Im with Justin on the take that neovim can replace tmux soon literally all that is left is being able to restart terminal sessions on restart (which is even set as a goal for summer of code).

Neovim can already have all the agents running in different terminal buffers or there are plugins popping up every day to have deep integrations with your favorite or we even have some interesting harnesses that are unique to neovim like sidekick.

As always, the ability to compose small tools and edit any file allow neovim to stay relevant and more powerful than ever in my opinion while not forcing workflow changes like the others

What you’re saying is super interesting, I’ve been using my setup for so long I might have missed some of the latest updates. I spend most of my time on TMUX with Claude Code and vim side by side btw, but I’m using it just to search some specific code and making small changes. I mostly review on GitHub PRs tbh

Yea by having claude code in a terminal window within neovim rather than tmux you can leverage neovim commands to traverse, copy, paste and otherwise interact with the terminal window like any other buffer.

There are also plugins with more specific workflows but I like really seeing how much vanilla neovim can get done

Any tips on how to switch from Tmux to pure neovim?

I have one: don't.

Tmux is basically perfect software. It gets right out of your way.

It'll never come out of my development stack, or workflows.

Writing code isn't everything. Almost every time I start an apt command or something that might run a little while, I regret it if I'm not in a tmux session.

I could sooner do without vim than tmux.

I will concede that this is the primary gap in the ecosystem right now is PERSISTENT terminal buffers but the act of doing terminal work in neovim is straight up nice if you use neovim motions to leverage that relationship.

Terminals resuming in a session is just a feature to be added not a complete functional rewrite.

Vim (and the neo-thing) have multiple plugins that support vim-terminals but for agentic workflows tmux (a specialized tool) and similar tools (there are quite a few nowadays) are way better.

Knowing and leveraging the editor deeply is the best high level advice. Sessions for persistence, windows and buffers to manage screen real-estate (including terminals), and the terminal command itself to run the agentic workflow of your choice.

Use it to write and edit code when that makes sense for you to do so. Just like you always have. It's an extremely useful skill to have even still.

I've had much more success with agents reviewing my code and offering inline autocomplete over LSP than I have with letting the agents write the code, which I then try to review. I end up with a much better mental model of the code and higher quality output than either I or the agent could do alone.

"how do you use an ax in the age of AI"

Exactly the same as I used it on the age of frameworks, the age of Java and .NET, the age of compilers, the age of ...: you take it by the helve and swing the business end towards the object.

It is more like using skill saw in the age of IKEA.

When you use AI you are not programming, you are having a statistical machine deliver you inferred code which it got by stealing it from everybody else.

This is your carpenter going to IKEA and fitting a cheap furniture slop made by exploited workers in poorer countries, with cheap wood grown on stolen indigenous lands, into your kitchen, when you were expecting custom fit cabinets.

I use jj vcs and now most of my time is spent reading the code, so I use diffview.nvim (https://github.com/sindrets/diffview.nvim) with some customizations for jj to read diffs. I also use the snacks picker/explorer to search for code.

jj with agentic coding is really underrated. The automatic committing is awesome for being able to see diffs between every prompt, roll back changes done by a given prompt, etc.

I use vim and claude code (fable) inside of herdr.

I can jump to one tab look at the code, jump back over and talk to claude for a little.

I can spread this all across several projects using herdrs workspaces.

I still write code when it makes sense.

Sometimes i annotate the code with comments, hop back over and ask the LLM to consume the annotations i just added and make changes.

Sometimes i ask the LLM to analyze lots of code, and come up with a plan of attack for me, then i go implement it myself.

For Personal projects I write much more of the code myself still, because i enjoy it. For work, i do whatever gets the best outcome most efficiently.

I've taken a look at herdr and I am confused, what does it offer over using Blink terminal from iPhone and tmux on the server?

Not familiar with blink but I use tmux heavily. Tried herdr but did t stuck. The main selling point is the status report: tmux requires a plugin and even that doesn’t work as good as herdr. By reporting I mean that while a tmux plugin can report a very basic “status” in the powerline, herdr does so natively in greater detail (reports if the agent waits for use input etc). All solutions I came across with status report might support one agent / cli app and not others… so there is that.

It makes sense even more. If you never enter "insert" mode, you still have powerful navigation and overview capabilities. `*`, `#`, n/p, :set fdm=indent + zM/zR, gf/gx, :bp, the venerable `}/{` pairing, and simply `C-n/C-p` while composing prompts can be useful.

AI + Prompting can get you there, but it's still fairly laggy. Honestly, VSCode (aka: Cursor) w/ the vim plugin, and `F2-rename` has been the sweet spot for me. Reviewing diffs with `git diff | view -` and browsing them with vim is another useful.

:wq

like normal?

but i don't use ai to write code for me -- i use it as a companion thing where i ask questions and then, instead of asking for code, i implement everything myself.

it keeps me sharp and helps me understand the lastest ai stuff.

I see a lot of valid points, so let me specify better: now that the way we write code drastically changed, did you change anything in your vim setup? Like plugins, habits, anything?

Right now I'm using TMUX with Claude Code and Vim side-by-side, but I mostly use vim to look at the code and make small changes, while I review the code changes directly on GitHub PRs.

And yes, I admit I look at the code less than before. For as much as I'd like to say it's untrue, I'm increasingly spending time in crafting skills to make sure they don't break the code, trusting the Coding Agent more and more, and consequently looking less at the code itself (which it doesn't mean I don't know how it works, I am in a sort of "reviewer mode" as a coworker writes it, with additional care and attention ofc).

So yeah I was wondering how did it change for you and if you think it still makes sense (it's my understanding that the agreement is "yes" apparently, with which I tend to agree!)

I removed most of the the autocompletion plugins from my Vim setup. (I had YouCompleteMe set up for intelligent suggestions, I've rolled it back to a simpler LSP-driven setup).

Also, I no longer update plugins without first manually reading the source diff to see if they've been infected by malware.

I still look at the files I want to change so that it doesn't go off and grep the entire project unnecessarily, burning tokens or getting the wrong idea.

So I still use a ton of fzf.lua to find the files to change and I have just added some keybinds to copy the open file path to the clipboard so that I can paste the path of the file to change it into opencode.

Code diffs I definitely look at locally with delta via lazygit or jjui. codediff.nvim is also good for resolving conflicts.

The main thing I've changed is just using JJ so merge conflicts can be resolved later by me manually without it blocking bringing in new changes.

If I just hand over the thinking entirely and don't know what has changed until I'm looking at it in GitHub I feel that removes the need for me entirely as by that point I'll be biased and will be less likely to change things to how I'd like them to be.

You're not looking at the code?

I'd even go so far at to say that if you're not writing the code yourself, you probably need to look at it even more than previously.

Even before AI most of us read way more code than we wrote, that should still hold true.

You're ignoring that AI coding attracts a whole new crop of people who would never have touched computers before. We live in interesting times.

That's fair, but I wouldn't think those users would be using vim either (probably vscode)

Codex has /diff to review the code, or you can look when it’s a Pull Request

Codex can also delete all your files if you ask it to.

Just because it can do it, doesn't mean that it's a good idea.

Crazy to me that people are producing code they don't read, expect another human to review it or just let ai take the wheel and review. Then yeet it out the window into prod.

Why are we not ok with this for our cars, but we are ok with this for our software(banking, health care, etc.). Doesn't make any sense to me.

I use Vim the same as before.

I run claude cli inside nvim as my main ide. It is 3 pane: nvim-tree/editor/agent terminal + popup terminal, I switch M-1/2/3/4 between those. ~700 lines of lua config. It has editor sync on agent writes, auto format hooks for claude, os alerts, resume claude session, and usual vim telescope/lsp/gitgutter.

Quite satisfied with that, haven't opened vscode/zed in a while. Making something like that is easy with LLMs now.

I've barely touched Intellij for the last half year or so. I rarely edit code manually at this point. I also did not renew my subscription and am back on the community edition.

I've noticed that my preferences for tools and languages is shifting as well. I'm happy to work with stuff that I previously would have not touched now because it would take me too long to get up to speed with languages, frameworks, etc. That stuff no longer blocks me from being productive. I still care about code quality, good design, etc. but a lot of that stuff doesn't require me to micro manage a code base. In the rare case I want to open something in an editor, I use vs code. I've removed a lot of the plugins in that as I'm not really using them any more.

I actually do reach for vi on the command line sometimes. But I've never been very good with it. I know how to do simple edits and save the file. I just never really got into it. I memorized a handful of key bindings somewhere in the nineties and that's it. I know some people that live in this editor and swear by it but for me it's just something that's there by default that is vaguely useful in a pinch if there's nothing else.

I’m still not exactly at the point where I don’t need the IDE. I still like Idea products for their indexing and navigation - I’m just used to them.

Codex doesn’t yet do a good job showing diffs nicely. Nor with navigation.

I agree I reach out to the IDE less and less now.

Just change the idea that vim is the IDE. It's tmux/terminal. That gives you access to thousands of tools right inside your IDE.

There's a ton of tools for viewing diffs. I just pipe the diff into a viewer with vim-style navigation.

Finding files in vim is great, with the "ctrl+p" plug-in .

Tmux with vim as a 50% split, I’ll run an agent in a quarter split.

I have neovim hooked up to a local llama.cpp (through lemonade) for completion, but I have not found a plugin that I’m happy with. Avante is probably the closest because you can give inline instructions, but it both got very very heavily and stopped working with small LLMs so I uninstalled it. I’m using minuet currently.

I am sort of a no UI (except browser) user for a very long time now, and vim is still incredibly useful.

Granted, the language servers are getting dusted, but it's much nicer to write goals in markdown in vim and send it to LLM in a self-written harness CLI; and even look at the results in the same way. All unix. LLM is just the latest toolbox addition.

I started using Neovim - AstroNvim specifically is pretty good - to keep my hands on the keyboard at all times, of course, but also to scroll through Claude Code's output in a terminal using vim motions, read the code it's outputting and the oftentimes overly verbose explanations it's giving.

Most of all, Neovim is helping me keep an eye on the code I develop at all times, and helping me keep writing code manually as well. It think it's especially important to be mindful about what we're doing these days because we're at risk of all becoming vibe coders as the AI assistants improve.

In essence, this is how: hjkl, G, gg, $, 0, w, b, e, i, y, p, <leader>e, <leader>o, <leader>ff, <leader>fw, /, dd, dw, grr, ]b, [b, :w, :q, :wq, etc... :)

I use Emacs more in the era of AI than I did prior.

I'm writing less code, but I'm reviewing more code. And I use magit in Emacs for reviewing code.

And I run my agents inside my emacs. I use my emacs like most others use tmux -- my emacs session is persistent and I connect with emacsclient.

Coupled with tmux and tmuxinator. Vim in the editor pane1, shell in pane2, agent(s) in panes3+. I rename the pane’s name to map try work done there. I rarely work with more than three agents, most of the it’s just one because I spent time reviewing the changes, performing tests in the shell pane to make sure everything is as it should be.

Ps. I use an the vim-ai plugin (dot files available in GitHub alongside vim config) but it’s not ideal for agetic workflows.

Usually I keep terminal split open with the agent side by side and make edits by hand where needed or for reviewing the code. Inside the vim itself I have a small plugin that you can feed a block of text with the comment instructing LLM what to do. It then replaces the text with the result of execution. Super useful for small edits here and there that don't require full session. I also have preconfigured neoterm float with the pi agent, that allows me to jump into the session right away.

Even something as simple as using Vim motions to write/edit multi-line prompts is an improvement for me, and this is for things that have nothing to do with coding. But maybe that doesn't really count as "true" vim use?

Editing speed was never the moat — navigation was. I read far more diffs than I write code now, and vim motions are still how I get through them fast.

> Editing speed was never the moat — navigation was.

This. Also, ergonomics. With vi bindings you can navigate anywhere in a document without moving your hands away from the keyboard. As a neat consequence, you see any repetitive strain injury magically vanish.

I don't think anything has changed for me regarding my vim usage. Previously, I would use vim to make simple changes in the code or configuration files, making larger changes in VS Code. Now, with agents, I never need to make larger code changes manually so I completely ditched VS Code, but I keep using vim in the same way as I did before: for small changes which I want to make manually, for editing configs, or as a scratchpad.

^G in Claude and Codex will drop you into $EDITOR to edit your prompt. I use that all the time.

"vimdiff" is a really great way to review code changes side-by-side.

I switched from using Vim as my primary editor to using Zed's Vim Mode. When you have a second process editing your project in the background you need an editor that can display those changes immediately without clunky buffer reloads.

I've also customized Zed's UI to optimize for reading and reviewing code, and mostly adding notes or small focused edits, rather than writing entire files from scratch.

I’ve done the same. Curious, what changes have you made to optimize the reading and reviewing?

Mostly moved my panels around to emphasize navigating code and looking at diffs side by side. Less emphasis on terminals, task runners, debuggers, test suites, etc. - I can pop those out if I need them, but usually I have the agent run my CI suites as a pre-review step anyway.

On about day 2 of using Fable I realized that the .vimrc I'd been maintaining for 15-20 years would probably never change again.

With Opus I still feel like I'm pair coding and want to get in there and make some changes myself, but working with Fable (even Fable managing Opus agents) had me in a completely different mindset, one where I realized I would just be getting in the way.

A couple years ago I decided to stop maintaining a .vimrc (after ~35 years), and started using LunarVim and later AstroVim with as few customizations as I could live with.

But then around 2 months ago I decided to switch to NixOS and there wasn't a Nix way I could find to use Astro. So I had Opus build me a vim setup for NixOS that included the batteries I wanted in my setup. I gave it a paragraph description and it built something that has been a joy to use.

This makes me sad. We've lost something.

Yeah it makes me sad too. It's a one-way veil, no going back once I experienced the new magic.

Sometimes I pop back into a terminal, mkdir, git init, crack my knuckles to do some all-natural hacking and the sadness sets in before the hour is up... "why am I insisting on doing this the long way? I know this project would be better with me in a different role now."

Coding for me has always been a balance of process and ends. Getting done what I wanted done mattered most, but I can't pretend that I didn't also enjoy being the moving parts of that process. And I am most grateful for what I learned by throwing myself over and over against problems I didn't quite know how to solve. There's a satisfaction to doing a thing well that I always love being a part of, still do, anything, even doing the dishes or laundry.

And just recently with Opus I found myself having some really joyously manic days and weeks, making calls, picking tech, designing APIs, insisting on quality, keeping agents spinning. But Fable just kind of came in with "oh, I can do that all for you too. You can relax," and that was both exactly what I wanted and what started making me realize this had all finally caught up to me.

I never wanted to be management, but I can't unsee that I am more effective now playing Fable's boss than I was the last few months as TLM of a squad of Opuses, and that was more effective than just coding myself the way I love.

i use vim quite a bit! I find that in this new era, i'm in the command line a lot and like to stay in the command line. vim (I use neovim) is a good way to do that.

Furthermore, a lot of my workflow is now done on remote servers (i love exe.dev) where claude code is sandboxed to an extent (it can still cause damage, just not to my main computer's file system). When I'm configuring those, i have a setup script that installs all of my vim files just the way i like them, so vim behaves exactly the same on a remote server as it does locally. I can edit things as needed. I can also access claude code on those servers as well. So working on my remote machine feels a lot like workin locally [1].

[1] I'm aware that i can setup cursor or vs code to access SSH servers, but it's just not as easy and doesn't feel as natural, IMO. There's something i like about needing to call `ssh remote-server` first.

Moved on to vis a few years ago and never looked back to vim/neovim. Granted, it doesn't have all the sparkles of the former, but it's way leaner and snappier - and you can tell there's no ai in it.

https://github.com/martanne/vis

I did a write-up at https://blog.miloslavhomer.cz/vibing-with-french-models-in-n....

It really can be a fancy auto complete, but more agentic usage moved out of the editors (and I think that's a good thing).

Funnily enough, I have my agent use vim sometimes.

I prefer commits to be granular to the extent that I manually edit the patch in git add -p, albeit rarely. So I have a pty plugin that my agent literally sends control codes to. This is also useful in general for LLMs driving any interactive terminal program. Long live text, I guess.

Typically when I ssh onto somethign like an ec2 instance. Its easier for me to just vim a quick change or setup or something than actually get my agent involved.

Vim helps me ground my AI usage to my workflow. It is so pleasurable to edit text with Vim that it keeps me writing skeletons for the AI to fill according to my design instead of delegating design to the AI.

I usually have tmux with two tabs - one opencode one neovim (and a third for cli )

Definitely not a vim power user though. I just like writing markdown spec-ish prompts and opencode simplistic input box isn’t ideal for that

https://github.com/ggml-org/llama.vim

I use only Neovim, and paired with CodeCompanion it is really powerful and ergonomic, way more them combining external harnesses. At least for me.

Hasn't changed at all since AI agents became a thing. tmux, nvim with a few plugins, mainly fzf and LSP support. If I do use an AI agent, I just run it in another tmux window.

I still use Vim, but totally different from before. I don’t care about efficient movement/editing bindings. All I use it for now is navigating and viewing files.

Vim/Neovim have only grown more powerful in the age of AI, not less. I am certain that even 30 years from now developers will still be using some form of vim.

I spend more time reading, navigating, reviewing and refining code than generating it and vim is still the fastest tool for that.

I have jetski/antigravity in one tmux pane and nvim in the other at all times.

I use it to write instructions, obviously. I thought everyone was using C-g on Claude Code

I have my own coding harness (std::slop), in that i focus on a vim centric flow. Basically a few commands open. up my $EDITOR which is vim.

1. /edit => opens in editor

2. /feedback => opens the last llm message in an editor so i can inline feedback. Think inline responses in email vs bottom posting.

3. /review => same as /feedback but opens up the diff so i do an inline review. Yes I still read the code it ships.

So basically in this flow vim becomes integral to doing anything involved.

copilot.lua, CodeCompanion when I want in-editor agents (hooked up to OpenCode), OpenCode web for most everything else. Neovim works fine in OpenCode web's terminal too.

I switched to Emacs. Whatever AI did to TreeSitter caused it to constantly yell at me about errors because of markdown which I do not have the energy to figure out, while losing syntax highlighting and formatting support entirely whenever that happens.

Otherwise though - same as usual, although I do keep my AI agent and my editor separate since I still choose to review, verify, and even write a lot of the code myself (too poor to constantly throw money at an LLM)

I’m not using any AI. A lot of us aren’t. Vim has done me well for 30 years so I’m not going to throw that away to sharecrop on someone else’s land.

I see coworkers reach for AI to perform many tasks that are made trivial by a few keystrokes or a simple macro in Vim.

Your macros are not implementing features, fixing bugs, and writing test cases.

I literally just watched someone do a text replace on a conference call to show me how good Claude was today.

They are. And have been since the 1970s, and will continue to do so for another 50 years.

Particularly the fixing bugs parts. So often is one bug manifested across 200 lines in 50 different files, and to fix it you need the same 5 exact keystrokes across those 200 lines. vim (or in my case Emacs) macros will allow me to find the fix in the first of these lines where I also define the macro, and then apply in mere seconds across the other 200 lines.

As for writing test cases, copy-paste has worked fine since unit tests became popular in the 1990s, and will continue to work fine for the next 30 years. editor macros are not too dissimilar to copy-paste-edit.

Said with such confidence...

Which is fine. Burn your tokens (with all the carbon emissions they generate in data centers) doing more involved tasks like that. Don’t waste it on silly, easy things like simple macros, search/replace, etc. AI doesn’t need to be a hammer used for everything.

This is patronising. We know what macros are. There’s benefit in general, adaptable tools, even if some tasks can be accomplished with something more rudimentary. That’s not the point. Hell, the software that you’re so proud of writing with vim could very well be superseded by someone using an LLM to do it in a worse, more wasteful way. But it’s the tool that’s there, and it’s the tool that they use for everything else, and it more easily ties into their workflow.

Comments like this are increasingly just the sounds of someone sticking their head in the sand.

Does that answer the question? Or can you just not help mentioning that you don’t use AI? Because if so, congrats! I’m sure you’re very proud of yourself.

It does if you read deeper into the answer. They are two different worlds.

It literally doesn’t answer the question. “I don’t qualify to answer” isn’t an answer. Don’t tell me to “read deeper”. We are all reading the same comment. You aren’t more intelligent than anyone else here.

Rejecting the implied premise is a legitimate answer

Q: How to properly grill a steak? A: I'm vegetarian; do not eat meat. Completely irrelevant for the question asked. But I do feel the need to express how superior I feel about it.

Sorry I didn’t throw the answer grenade in your face like Claude. It’s there if you look for it.

You are trying to save face. You didn’t answer the question. You don’t ‘speak for a tribe of Real Developers That Use Vim’ or whatever. You just aren’t qualified to answer but couldn’t help getting on your soapbox.

I know a couple of vim users at work that *do^ use LLMs for coding tasks. Let me guess, they aren’t from “your world”. They aren’t real vim users. Get over it.

"I'm not using any AI."

Nor am I

This seems to trigger argumentative replies on HN, including personal attacks

How do we explain this

Cognitive dissonance from being confronted with evidence they're not actually speeding up, when us non-AI devs are only having issues with managers pushing it from above even though we're not actually falling behind?

I also use vim and don't use AI.

'a lot us' you say? just speak for yourself so at least you will sound confident; all you've demonstrated here is your ignorance of LLM, and those who use it, and you amplify that by throwing silly examples to prove your ignorance.

llm usage or not, code browsing/refactor etc still need human usable tools like vim/git/tmux etc.

The intersection of people who like vim and ai is basically nil

There are few people.

that is untrue

Can confirm. Using vim same as always. Do not use any so-called ”AI” whatsoever.

My Neovim + AI workflow is running Neovim (LazyVim) and Claude Code side by side in a terminal split. As the agent makes changes, I review them in Neogit. I don't really make edits by hand much anymore, but the keyboard is still how I navigate the code when doing reviews. I can jump to references, open files, read through the diff very quickly with keyboard shortcuts.

The Neovim/LazyVim speed for writing code turns out to be just as fast for navigating and reviewing code.

I'm trying to figure out who you're trying to slight...

Either way I'll happily be part of your `nil` category.

It's vim.NIL

Reply on news.ycombinator.com