Trying out Zed after more than a decade of Vim/Neovim (sgoel.dev)

https://zed.dev/blog/remote-development

As the author describes though, I found myself copy-pasting a lot between LLM chat and editing buffers. In tmux, I have a really simple function that copies select panes (using tmux capture-pane) into my prompt, or I can give it full files for context. Most of the time though, I can do something like `llm -t 0 -t 1 'what is this libSSL error indicating? here's my code', where -t 0 gives it my vim pane and -t 1 gives it the terminal I'm running things in. I've been surprised that this somewhat rudimentary approach has felt far more effective than the more sophisticated editors I've been trying.

Is this just me? Does it seem to others that the LLM-enabled editors coming out these days still require a lot of copy-pasting of context that can be easily provided with just a dump of tmux output?

Everything-is-just-text might be crude but dang does it make quick and dirty LLM integrations a snap!

I have Ctrl+` set to switch focus between the editor and the terminal panes in VSCode, so I can toggle between them pretty easily as this is also my workflow

If anyone's wondering, here's what I have in my keybindings.json

    {
        "key": "ctrl+`",
        "command": "workbench.action.terminal.focus"
    },
    {
        "key": "ctrl+`",
        "command": "workbench.action.focusActiveEditorGroup",
        "when": "terminalFocus"
    },

I know people who use ^Z to suspend vim and then foreground it again.

https://helix-editor.com/

It's a terminal editor with mouse support and sane key bindings.

I don't know if I'm an AI fanboi or not, but for generating things like factorygirl definitions and simple rspec unit tests, GPT is seriously good (in the sense that it saves me tedious work, not that it is particularly fantastic).

Sublime has great language support out of the box but poor LSP support (basically outsourcing it to a user plugin instead of having a native integration).

Zed has great LSP support but ”poor” language integration (also outsourcing the language plugins to the community, which makes the vary in quality and feature set).

But Zed has great AI integration which Sublime completely lacks, if you’re into that.

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

https://github.com/baketnk/l.nvim (self-shill, docs overhaul needed)

which was inspired by the original:

https://github.com/yacineMTB/dingllm.nvim

Also brand new from ggerganov: https://github.com/ggml-org/llama.vim

dingllm is very straightforward, you submit your entire selection/buffer and it streams out to the current position. mine is a bit more complex with configurations, context management and so on.

The thing I always tell people is just roll your own. The docs are there, the LLM is there, use them. At the end of the day it's just an http call against text from your buffer to put text in a buffer.

https://zed.dev/blog/vim-2025

It's be kinda cool if Zed had a TUI mode (in that the rendering engine would generate VT escape sequences).

I've been editing directly in the terminal for many years and was looking forward to moving back to a real desktop IDE, but I bounced right off of this. Does it not happen for you or it's just not that bad? Does anyone know of a solution?

But man. File trees and tabs are the worst DX I can possibly imagine. Try as I might, I just could not get used to the tab and tree workflow. Creating new files killed me. Hiding the tab didn’t really help because the editor assumes you’re using tabs and at that point it doesn’t feel like buffers, it feels like tabs with the tab bar hidden (go figure).

I’m not even a buffer power users, but I think the default assumption of buffers over tabs, and explore over a file tree, led to 1000 other great decisions that make vim vim.

I think unless the zed core team really tried to move away from tabs and trees (and I don’t think they would nor should) they’ll fail to capture a meaningful share of vim users

because when the very customized setup inevitably breaks the amount of headache you have is roughly proportionate to the amount of customization, whereas software with strong defaults tends to deal with that for you.

This is particularly the case with neovim which, in almost deliberate defiance of any systems thinking, just tends to consist of a few dozen moving parts loosely tied together and you have to sort of pray that updating some doesn't just break things. Paraphrasing Russ Ackhoff, if you take the best part of every car and put it together you don't get the best car, you get something that doesn't even drive, this is how I've felt more than once with very bespoke editor setups

Or, to put it another way: every step you take away from the mainstream has a cost, so you had better know how much you are willing to pay and budget your quirks accordingly.

That's one of the reasons why I chose Vim over Emacs after switching back and forth for a while.

I do prefer the design of Emacs because I prefer having full control over my environment - I even coded more than a couple of tiny, application-specific editors - but sometimes I have better things to do than e.g. reading docs or searching for a plugin/extension mod that does what I need, or do it myself; sometimes I am a mere luser who want things to "just work" out-of-the-box.

What drew you to Zed over VS Code?