Leaving the JetBrains Ecosystem

TL;DR

I leaving JetBrains for LazyVim. It was rough at first. 2 weeks of adjusting my muscle memory and learning vim motions, but now I’m genuinely faster and happier. Yeah, I miss some stuff like junie’s AI, auto generate test boilerplate, a really great debugging stuff, slick git UI, and many stuff. But the lightweight speed, customizability, and that “maker of my own tools” feeling is absolutely worth it. If you’re considering the jump, ThePrimeagen’s content actually slaps and the vim motion syntax is more powerful than you think once it clicks.

The Price Tag Reality Check

Let me be real with you: JetBrains is expensive especially for my country. Like, really expensive. Between their all-in-one subscription, all the bells and whistles, and AI features like Junie… the costs add up quick. When I looked at my annual spending on IDEs, I couldn’t shake the feeling that I was investing my money at a problem that open-source communities had already solved. Sure, JetBrains is incredible, but at a price.

I know, the price was understandable, and it was worth it to me back in the day. Also the price is decreasing up to 40% after 3 years. But still, it’s a lot. I’m not sure if I can justify it.

That’s when I started seriously eyeing Neovim and LazyVim. Free. Lightweight. Infinitely customizable.

What I’m Actually Gonna Miss

Okay, so I won’t pretend JetBrains doesn’t have some seriously magical features:

Junie and Automatic Test Generation

This one hits different. Just highlight a class, press a hotkey, and Junie generate all the things based on your command. It’s really boost productivity. Neovim doesn’t have a direct equivalent that’s as smooth. You can use AI tools through plugins, but it’s not as integrated or intuitive. I’ll miss hitting that generate button.

The Git Integration

JetBrains’ git tooling is really great. Visual branch management, review changes made easy, seamless conflict resolution, commit staging, it all feels native and buttery smooth. The git ecosystem is so good that it honestly made me more productive just by existing. LazyVim has good git support through plugins like Lazygit, but there’s a slight learning curve and it feels less “baked in.”

Debugging Without Friction

Breaking into a debugger in their products? One click. Setting breakpoints? Automatic. Conditional breakpoints with the click of a button? Standard. Debugging in Neovim is absolutely possible through nvim-dap, but it requires more manual setup and the UI isn’t quite as polished. It works, but it’s not as frictionless.

Alright, Why The Jump Anyway?

Beyond the cost, I was craving something different. JetBrains is incredible, but it’s also heavy. It’s feature-rich to the point where you’re constantly discovering buttons you don’t need. I wanted to control every aspect of my environment, build it piece by piece, and understand why things work the way they do.

I also don’t want to be tightly coupled to an environment where my creativity only flows if I’m inside their (admittedly excellent) tooling. Mastering vim motions gives me portable muscle memory I can take to any terminal, remote box, or cloud IDE without dragging the whole JetBrains ecosystem with me.

Plus, vim motions are genuinely powerful once we master them. They’re not just a meme, they’re a language for editing that you can take anywhere. It’s this portable skill that unlocks editing speed across your “digital life.” Whether you’re editing code, writing documentation, or just plain text, vim motions allow you to navigate and edit with precision and efficiency.

The Learning Curve Is Real (But Manageable)

Let’s not sugarcoat it: the first two weeks were rough.

My brain was screaming “just use the arrow keys!” while I’m trying to remember that w jumps to the next word and b goes back. The muscle memory was fighting me. I’d instinctively reach for the mouse, realize vim doesn’t really do that, and have to rethink my approach.

But here’s the thing: it wasn’t impossible. It was just different.

ThePrimeagen’s advice actually saved me here. Instead of trying to learn every vim command at once (which would be insane), I learned motions first. Get comfortable moving around. Then layer on editing commands. Then optimize. This incremental approach made it feel less like drowning and more like leveling up.

By week 2, things clicked. My brain stopped fighting the keybindings. Muscle memory started forming. And by week 3-4, I genuinely noticed I was editing faster than I used to from day one. Not a huge difference, but enough to feel real.

DevOps Toolbox and ThePrimeagen’s content on YouTube genuinely some of the best educational resources out there. Watching someone who really knows vim move through code at lightning speed is both humbling and inspiring.

LazyVim Is The Cheat Code

Here’s where LazyVim enters the chat as the MVP: it’s pre-configured Neovim on steroids.

Instead of spending six months tweaking Lua configs (which, don’t get me wrong, some people love), LazyVim comes with sensible defaults, a beautiful UI, and 80% of what you actually need out of the box. You want LSP support? It’s there. Git integration? Check. Treesitter syntax highlighting? Absolutely.

The beauty is you can still customize everything. But you don’t have to right away. You can start productive immediately and then gradually bend the editor to your will.

Setting up LazyVim is basically:

Clone the starter config
Add your custom plugins in lua/plugins/
Adjust a few settings
Done

It’s that refreshingly simple compared to building everything from scratch. I just want to everything is set up and I can start crafting features and stuff.

The Ecosystem Is Isolated, But That’s Actually Good

One thing I was worried about: would I feel isolated without JetBrains’ massive ecosystem?

Turns out, the Neovim ecosystem is thriving. Like, genuinely impressive. Mason handles LSP installation. Treesitter keeps syntax highlighting beautiful. DAP lets you debug. Telescope is essentially your fuzzy finder on steroids. The plugin community is constantly shipping features.

Yeah, it’s not “one IDE does everything.” But that’s actually kind of the point? You pick the tools that matter to you, configure them your way, and create an environment that’s 100% yours. There’s something deeply satisfying about that level of ownership.

Specific Things That Make LazyVim Shine

Out-Of-The-Box Features

Colorscheme: Comes with beautiful themes (I’m using Catppuccin mocha and it’s beautiful)
Keybindings: Smart defaults that feel natural but are fully customizable
Plugin Management: Lazy loading plugins for speed
LSP Setup: Language servers configured with sensible options
Diagnostics: Nice error/warning visualization
Telescope: Fast file finding and searching

The Customization Ceiling

With JetBrains, you customize within the boundaries they set. With LazyVim, those boundaries basically don’t exist. Want to add AI-powered completion? There’s a plugin for that. Want to change how your status line looks? Implement it. Want to create custom commands? Easy.

What I’m Still Getting Used To

I won’t pretend it’s all sunshine and rainbows. Some things I’m still adapting to:

Test Generation - I haven’t found a super smooth way to auto-generate test boilerplate. I’m experimenting with using Claude or ChatGPT directly, or Copilot plugins, but it’s not as seamless as Junie.

Debugging - Setting up DAP for multiple languages takes more effort. It’s powerful once configured, but it’s not as “open and run” as JetBrains.

Git Conflicts - Git conflict resolution is quite good using LazyGit, but requires more manual navigation than JetBrains’ slick conflict UI.

But honestly these are all things I’m getting better at. And there’s something empowering about learning the tools instead of having them do everything for you.

The Real Takeaway

Switching from JetBrains to LazyVim wasn’t about one being “better” than the other. It was about what I needed: freedom, cost-effectiveness, and a system that felt like mine.

JetBrains is still incredible. If you don’t mind the price and love the all-in-one IDE experience, stick with it. But if you’re looking for a lighter, more customizable, and genuinely free alternative that unlocks portable vim skills across your entire workflow, LazyVim is legitimately worth the 2-week learning curve (at least for me).

The muscle memory will come. The commands will stick. And one day you’ll realize you’re just… faster. Not because vim is objectively better at editing (though it kind of is), but because you’ve internalized a language for text manipulation that removes friction.

That’s worth the investment to me.

Summary

The transition from JetBrains to LazyVim was driven by cost and curiosity, but kept by genuine productivity gains. While I do miss Junie, the beautiful git UI, and frictionless debugging.. the speed, customizability, and ownership of LazyVim make up for it. The first two weeks were rough, muscle memory and vim motions don’t come naturally, but ThePrimeagen’s content and LazyVim’s sensible defaults made the journey manageable. Now, a month in, I’m genuinely still learning and happier with an editor that feels like mine. It’s not about picking the “better” tool; it’s about picking the tool that fits your workflow.