I’ve been a developer for a long time now. I have tried almost every editor out there. I started with Notepad++ when I coded for the first time in C, then moved to Visual Studio, Sublime Text, VSCode, Atom, JetBrains, and now to the latest Zed and Cursor. I’ve even tried Vim for some time. I have to be honest here and not write from excitement but from pure love for coding.

I am going to give a detailed overview of what features an editor needs for me and what overall is the best. I say overall because in some niche areas, some other editors or IDEs might take the lead. But in general, I am going to give a score from 1 to 10 on each editor in these categories.

• Efficiency

• Cost

• Coding Speed

• Extensions

• LLM’s

• Developer Experience

Before we continue, let me explain in more detail what each of the categories means. Efficiency refers to both system resources and the overall performance of the editor, including how it behaves under large projects.

Cost refers to the pricing of the editor, if any, as well as the pricing of LLMs and extensions.

Coding Speed comes from both a good UX and the tools integrated into the code editor, along with the features it gives you out of the box.

Extensions refer to the size of the community around the specific IDE plugins and extensions.

LLMs refer to the overall usage of LLMs in the editor, what options exist, their cost, and how well they work.

Developer experience is the overall feeling of the editor. It also considers if the IDE makes you a better developer and what tools it provides for that.

Before we start I want to say that we are not going to discuss for every editor out there but for the top 5 right-now. VSCode, Cursor, JetBrains, Nvim/Vim, Zed.

Efficiency

Let’s start with the category of efficiency. Here, most editors score well. VSCode is doing good, and it shouldn’t, to be really honest. Yet, this shows how much more efficient and lightweight Electron and Typescript can be compared to Java and Kotlin. VSCode and its forks are built around these technologies, making them overall fast. They don’t use many resources, and even on large codebases with hundreds of thousands of files, they perform really well. For me, VSCode uses around 300-350MB of RAM in an idle state on my MacBook. Also, under debugging sessions, the performance stays the same.

I am not even going to talk about Vim here because, by far, it is the best-performing option except for one of our competitors, which I am going to talk about later. But first, I need to talk about JetBrains and the fact that a piece of software can be that bad.

Using 3GB of RAM and 28GB of cache storage is really obscure. For me, as much as I like JetBrains and have used its products for a long time, this is something they need to look at. Yes, you heard it right. JetBrains, for 5 projects in total, had 28GB of cache files. I found out randomly when CCleaner always reported 20-30GB to clear from JetBrains, but even when I did, the cache after a few days was full again.

Their poor performance and efficiency is a big downside for me. To use their IDE properly, you need at least 32GB of RAM, and even then, if you are on battery, it will drain it like crazy compared to other editors.

Now let’s talk about Zed my favorite editor of all, by the end of the article you will understand why. On idle state it uses around 80-120mb of RAM. But this is not only the case. In terms of performance is the day and night compared with other editors. It never lags, doesn’t use any cache and every pixel deserves it’s position on the screen. This is the power or Rust and a game engine.

Scores:
JetBrains: 2/10
VSCode: 7/10
Cursor: 7/10
Zed: 10/10
Vim: 9/10

Cost

Cost is really important, and I want to focus on that because nowadays we end up paying $20 per month for everything we use. At first, it might not seem like a lot, but if you pay for 10 subscriptions per month, it adds up. The good old days of the web are gone; if something wasn't free, it costed $5.

I want to start with Cursor. It is expensive. It costs $20 per month and gives you 500 fast requests. For me, after 15 days of coding, I didn't have any more requests. So I had to pay an extra $20 to get 500 more. If you think about it, 500 requests are not much, especially if you code and debug a lot.

Besides that, I don't think they offer anything else. You pay the money just for the LLMs. I don't know how much it costs them, but they could easily try not to drain their customers and go to a more reasonable subscription model, like providing the API keys for the models as Zed does. Or they could close a special deal with Anthropic, cut the pricing in half, and use only Anthropic for their fast requests.

I believe there are a lot of solutions, and if they wanted, they could be cheaper. JetBrains is around $30/month for all of their IDEs, but if you use their products for a long period of time, the pricing lowers significantly. For me, it was around $18/month after 2 years of usage.

I want to mention here that on JetBrains most of the plugins are free, but on top of your subscription you have to use your own LLM so for me was $10 per month more for the Copilot.

Score:
JetBrains: 4/10
VSCode: 10/10
Cursor: 4/10
Zed: 10/10
Vim: 10/10

Coding Speed

Now let’s talk about coding efficiency—how productive you are with each editor. I must say this depends on your experience level. Some editors, like JetBrains, might be better for less experienced developers because it gives them more tools and out-of-the-box features to work with. I am going to talk from the standpoint of an experienced developer, as I’ve been coding for more than 7 years now and have built a lot of large web projects.

Vim is said to make you much more productive, yet I don’t believe that. I’ve spent a good amount of time learning to use nvim seamlessly, but let’s be honest here, you can just use VSCode with vim keybindings. Vim is a bit more for coding geeks and is fun to code on for your side projects. You might be slower, but it is worth it sometimes.

The only developers I know who code fast on vim are those who have either used it for 10 years or are really, really good with computers in general.

Now that we got that out of the way, the next in line is Cursor. Their auto-complete feature as a Copilot alternative is impressive. It works so well that on simple web projects, I don’t really write code; 90% of the time, I just hit tab. Your productivity with Cursor skyrockets, but this comes with some downsides, which I will discuss later.

JetBrains is good here; it offers a solid set of tools to make you code faster, but nothing that VSCode doesn’t have. Their debugging is better, and so is its Git integration, but if you are an experienced dev, it doesn’t really make a difference.

Zed, on the other hand, would be in the same position as VSCode and Cursor for me, but it lacks a debugger, so it loses a lot of points for that.

Score:
JetBrains: 8/10
VSCode: 7/10
Cursor: 10/10
Zed: 6/10
Vim: 3/10

Extensions

Extensions are a crucial part of your coding speed. This is because IDEs can't support every language out-of-the-box. They need to support LSPs, plugins, etc. From my perspective, extension-based editors like VSCode are better than having everything bundled in, like JetBrains. This is because there are features you might not actually need, and they take resources from your system.

As a marketplace for extensions, VSCode is the king, but JetBrains has a lot as well. The truth is that in both environments, you can basically find an extension for everything. Vim doesn't hold back either; it might seem at first that it is less extendable, but the truth is Vim has endless extensions to choose from.

Also, in this section, I will include how customizable each editor is. For this, Vim might actually take the lead because not only does it have extensions to choose from, but also with Lua, you can customize it however you want, something that is not directly available to all the other IDE’s.

Zed has a very immature marketplace, yet this is completely normal because it is not in version 1 yet. I believe in the next 2-3 years it will have as many plugins as VSCode.

Score:
JetBrains: 7/10
VSCode: 8/10
Cursor: 8/10
Zed: 5/10
Vim: 9/10

LLM’s

Now let’s talk about something I have been eager to write about, but saved for the end because there is a lot to discuss. First, we need to talk about LLMs in general. LLMs just provide an API; how each IDE utilizes that API is what is important. This is what we are going to discuss: how well an IDE works with these models.

But what is considered good utilization of LLMs? For me, it is not about how much code they produce. You might say Cursor is the king here, but this is not true. For me, Cursor is the worst of all. The reason is that it might have very good autocomplete from a performance and output standpoint, but compared to GitHub Copilot, it is much worse. Let me tell you why.

Autocomplete on Cursor gives you a lot of code, so much that when I code on Cursor, I don’t really write code anymore. I won’t get too deep into this topic because I wrote an article about it, which you can find here:

https://sotergreco.com/what-llms-for-coding-should-actually-look-like

But what I have to say is that not coding is really bad because you lose touch with the codebase and you don’t actually know what you are coding.

What is more important, in my opinion, is the interface you have. Cursor has a simple chat window. It is like having ChatGPT chat open, but inside your text editor. You can also add files as context. What makes Cursor different from other IDEs is that you have context and can choose the model you want. But for me, Cursor should have been a VSCode extension and not a different editor. What Cursor does can be done easily with an extension.

The best experience I had with an LLM interface for coding was with Zed. This is something you actually need to take a look at. It doesn’t treat the chat as a regular chat but as a separate editor window with many unique features. I could talk about this for much longer, but it’s better if you take a look at it yourself and try it.

I believe there is much improvement to be made on this area, the first step towards a better solution has been made only by Zed so far, but I hope in the future to see even better implementations.

With that said, let's give the scores. Vim also has extensions for this, so it isn't much different from the alternatives; it is just a little difficult to set up.

Score:
JetBrains: 4/10
VSCode: 4/10
Cursor: 5/10
Zed: 7/10
Vim: 4/10

Developer Experience

Now for our final comparison, we will talk about the most important aspect: developer experience. This is about how easy, fun, and effective it is to code in each editor.

Starting with JetBrains, for me, the developer experience, except for Java development, is really bad. Having 20 different editors is a really bad decision made by the company. It should have been one IDE from the beginning. Only for this, JetBrains loses the game for me.

Continuing with Vim, I have to say, it is challenging and unique to work with. Yet, the ability to customize it as you want and make quick changes to any file from anywhere is amazing. Also, Vim is not boring at all and is fun. In terms of difficulty and learning curve, Vim loses a lot of points, but the overall score is not going to be bad.

VSCode is the king of editors. This is no luck for me; VSCode was and will always be an overall winner. It is fast enough, extendable enough, and customizable enough. It has enough of everything. As a development experience, I can’t say it is bad; rather, I’d say it is great. Cursor also goes into the same bucket with VSCode, but it gets fewer points because it is expensive.

Before I continue, an important thing for me is Open Source. This is part of the developer experience because not only can you see the future logs, be part of the community, and solve any problems you might have with a PR quickly, but it also shows respect to the programming world and the community in general. It shows developers that you are not there to exploit them and that you actually care about something.

Zed takes extra points for that because it open-sourced the entire codebase. This is not a normal project. The people behind Zed actually made a breakthrough in IDEs; we had years to see something new. The only new thing was IntelliJ when it came out, which is actually bad software. Yet Zed made a game engine and approached coding as a game on a programming language of the future. Rust might be low-level and super fast, but it is also relatively easy to code.

Score:
JetBrains: 5/10
VSCode: 8/10
Cursor: 8/10
Zed: 8/10
Vim: 6/10

Let’s talk the look at the final results.

The results might surprise you, and to be honest, they surprised me too. At first, I thought VSCode would be the winner, but with a better performance score and LLM usage, Zed took first place.

I want to say that for some niche engineers, another solution might be better because they might have different needs. But for a Senior Engineer working on multiple projects and doing a bit of everything, I think the results are actually correct.

For Java or Kotlin developers, JetBrains wins. For competitive coders with a 192 IQ, Vim wins. For frontend junkies who just want output performance, Cursor is the best.

For beginners, VSCode is great. Yet for a Senior Engineer working on multiple projects with different languages and wanting a daily driver, Zed, despite being in the beta phase, is the overall best solution.

Jetbrains: 30 -> 5/10
VScode: 44 -> 7.3/10
Cursor: 42 -> 7/10
Zed: 46 -> 7.6/10
Vim: 41 -> 6.8/10

Thanks for reading, and I hope you found this article helpful. If you have any questions, feel free to email me at x@sotergreco.com, and I will respond.

You can also keep up with my latest updates by checking out my X here: x.com/sotergreco