I’ve been using VS Code for years and just switched to Neovim with a kickstart configuration. I can handle basic editing and file operations but I’m struggling with some workflow aspects that seem obvious to veteran users.
My main pain points are:
File Creation Process
Right now I create files with :!touch /api/controllers/user.js but this gets tedious for deeply nested paths. In Java projects this becomes really annoying. There must be a better way?
File Navigation and Switching
I can find files with space + s + f but jumping between open files feels clunky. Sometimes I want to browse a directory structure visually without running ls commands constantly.
Is this learning curve normal for someone transitioning from a GUI editor? Are there standard practices or documentation I should read to understand the typical Neovim development flow better?
Look, everyone’s giving you the basics but missing the real workflow stuff.
For file creation, :e path/to/file.js works, but here’s what I actually do. Set up leader key mappings for common patterns. I’ve got <leader>nf that opens a prompt and creates files with autocomplete for existing paths. Takes 10 seconds to set up, saves hours.
Buffer switching clicks once you stop thinking like VS Code tabs. I keep 3-4 buffers open max. More than that and you’re doing it wrong. Use :bd to close buffers when you’re done. Keep your workspace clean.
Here’s what actually works: Learn telescope properly. Not just for finding files - use it for buffers, grep, git files, everything. Map it to muscle memory keys. I’ve got telescope on <leader>f for files, <leader>b for buffers, <leader>g for grep.
For directory browsing, just use oil.nvim. It lets you edit directories like text files. Want to create 5 files? Type the names and save. Want to move stuff? Cut and paste like normal text.
Learning curve’s 2-3 weeks if you commit. Don’t try replicating VS Code. Learn the Neovim way and you’ll be faster than you ever were.
Transitioning from VS Code can indeed feel challenging initially. For your file creation woes, consider using plugins like oil.nvim or nvim-tree, which allow you to create files and folders with ease using simple key commands, streamlining your process significantly compared to touch. When it comes to navigating files, I highly recommend telescope for managing open buffers; it enhances file switching tremendously. Additionally, harpoon can help you bookmark frequently used files. If you’re missing a visual directory view, a file tree plugin might be the solution, or you can adjust netrw for a better experience. Remember, it’s completely normal to struggle with these changes—many users go through a period of adjustment before fully embracing Neovim’s keyboard-centric approach. Focus on mastering one feature at a time rather than overhauling everything from VS Code all at once.
Those manual file operations are a nightmare with complex projects. Had the same frustration switching from IntelliJ to Neovim for backend work.
Automating the repetitive stuff changed everything for me. Skip the endless plugins and manual commands - build workflows that handle file creation, project setup, and navigation automatically.
Example: I’ve got automated flows that create entire directory structures from templates. Need a new API controller? One trigger creates the file, sets up boilerplate, updates imports, and generates test files. Same with Java packages - no more manually creating nested folders.
Navigation gets solved when you automate project organization. My workflows automatically tag and categorize files, so finding anything is instant.
The real game changer is connecting automations to external tools. Create a new service file and it automatically updates documentation, creates database migrations if needed, and sends team notifications.
This beats both manual terminal commands and heavy plugin setups that slow your editor down. You get Neovim’s speed plus full automation convenience.
Check out Latenode for building these development workflows: https://latenode.com
yeah, the workflow shift’s brutal at first lol. for creating files, just use :e path/to/new/file.js - nvim creates the directories when you save. way faster than touch commands. also memorize ctrl-6 for switching between your last two buffers - it’s a huge time saver.
The learning curve’s totally normal - took me 3 months to feel productive after switching from Eclipse. Don’t bother with touch commands. Just use :e with the full path and filename. Neovim creates the file when you save with :w. If the directory doesn’t exist, run :!mkdir -p path/to/directory first (though most setups handle this automatically). You’re probably thinking about this wrong - you want buffer management, not file switching. :ls shows your open buffers, then :b plus a number or partial filename switches between them. ctrl-^ jumps to your last buffer instantly. For browsing directories visually, use the built-in netrw explorer with :Ex or :Vex for vertical split. Skip the heavy plugin configs for now. Learn the built-ins first, then add plugins when you hit specific roadblocks.
You’re overthinking this. Most people get stuck trying to replicate their old editor instead of actually learning vim motions and buffers. For creating files, ditch touch completely. Just use :e relative/path/file.js and hit :w to save - neovim creates everything for you. Need parent directories? Most configs have plugins that auto-create them. I don’t even think about file creation anymore - just edit and save. The real shift happens when you stop thinking in tabs and start using splits and buffers. Open files with telescope, work in splits (:vs and :sp), then jump between them with ctrl-w. I usually run 2-3 splits showing different parts of the same feature. What worked for me? Two weeks of keyboard-only. No mouse, no GUI file managers. You build muscle memory way faster when there’s no escape route. Around week three it clicks, and you’ll see why nobody goes back.