This is a post I have been updating from 2022-2025, to document the process of recreating my Jetbrains (Rubymine+Javascript) environment in Visual Studio Code. If you are moving from Rubymine, Pycharm, Webstorm, etc., to Visual Studio, I hope it proves useful.
For Ruby & Javascript (probably for other languages too), JetBrains does an excellent job of providing an IDE that "just works" for all sorts of desirable features that do not "just work" in VS Code:
Looking up CSS class/ID names by symbol
Looking up Ruby methods & classes by symbol
Navigating through search results preview (and changing code adjacent to the matched search preview) without using mouse
Browse all the lines that call a certain Ruby/Javascript function
But....there's a reason that VS Code represents something like 80% of IDE users as of 2025. With extensions, anything it possible. If you record music, I would analogize VS Code to "Reaper," where you can similarly do anything, but the initial learning curve to assimilate 1,001 UI options tends to be a steep one.
For my use case, the biggest payoff as of 2025 for learning VS Code is that the GitHub Copilot integration is considerably more robust. Whereas the Jetbrains Copilot plugin currently has no settings natively available in Jetbrains, the VS Code version of Copilot lets one configure a number of advanced/experimental features, including revising large code blocks (not just a Cursor feature!). It also lets you change your LLM Backend, at least between "Default" ✨ and "GPT-4o," the latter of which is claimed to offer much more context size (64kb) in a Github 2024 blog post (compared to what? They will not divulge).
VS Code is also free, which might appeal to some. I would argue that if programming is your profession, the cost of tools is immaterial. But, for hobbyists, this may be a substantive advantage.
The speed at which Cursor adds at least a....cursory implementation of any new LLM has been impressive. As of March 2025, they already have the Anthropic-3.7 Deep Think model, which debuted a couple weeks ago, as well as the Deepseek v3 model, which launched in the last couple months. Being able to interface with such a breadth of LLMs in a way that includes an arbitrary amount of code files is useful.
Steps taken to establish parity between my VS Code environment and the affordances I'm used to from Rubymine.
Fast way: Cmd+, that is: hold "Cmd" and press comma.
Slow way: Mouse over to the "Code" menu (leftmost among VS Code menus presented) and choose Settings -> Settings
First attempt followed settings that the internet seemed to think would work, but did not work for me:
Ensure that the main Ruby extension (from Peng Lv) is installed
Click the "Code" menu then click "Settings" -> "Settings"
Click the "Open Settings (JSON)" icon in the upper right
Add Ruby-specific settings to JSON file as suggested by Stack Overflow, or use the Ruby settings suggested by the Ruby extension itself
For me to get it to work, I had to continu trying more stuff:
Opened system "Privacy & Security" settings, and added VS Code to the list that of apps under the "Full disk access", as suggested by another popular SO post
Install Ruby LSP extension from Shopify (settings and install page)
Ruby LSP refuses to acknowledge rvm under all circumstances I could manufacture in 30 mins, so I instead changed rvm's system default Ruby to be the version from our project. That allowed the Ruby LSP server to start successfully, and thereafter, symbol lookup shows Ruby methods. 🎉
Once I struggled through the process of getting Ruby to look up methods, I was pleased to discover that symbol lookup was already functional to allow me to jump straight to a Javascript function.
The fastest way is to use the command palette (Cmd-Shift-P) and type "shortcut" then pick "Preferences: Keyboard Shortcuts". The slowest way to get to hotkey is by hovering "Code" menu then "Settings" and "Keyboard Shortcuts".
File open dialog to Cmd-O. Open "Keyboard Shortcuts" and look up "Go to file" and double click the "Keybinding" column to enter Cmd-O. You may need to click the link to "X existing commands has this hotkey" if there is a conflict that prevents your new mapping from focusing the "Go to file" dialog. It should go here.
Auto-populate text: If you're a Rubymine user, you probably want the File Quick Open to be smart enough to use your selected string if you press "Cmd-O" while a class is selected. As best I could determine, it requires manually editing the user's keybindings.json with the following commands
Go to definition. The "Go to definition" entry in Keyboard Shortcuts will navigate to the definition of the method/class/etc that the cursor is in. Mapping it to Ctrl-Space matches my Rubymine settings.
Go back (return). The "Go back" entry defines a means to return to where one's cursor originally was after using "Go to definition." Mapped to Ctrl-R matches my Rubymine settings.
Go to line. Default mapped to Ctrl-G, my muscle memory has it programmed as Cmd-G.
Go to next/previous change. The "Go to next change" entry moves through changes when reviewing staged changes. However, it only works within a single file, unlike Jetbrains, where F7 can move through all changes across many files. See "Go to next change" under "Extensions" for more detail about how my working solution for this.
Invoke git commit dialog. In Rubymine, Cmd-K opens a dialog that shows me which files have changed and lets me enter my commit message. To recreate this in Visual Studio, I searched for "Source Control" and mapped "View: Show Source Control" to Cmd-K, which opens a similar sidebar to what is available in Rubymine.
Look up all references with Cmd-T. Look the call sites from which a particular component or function is called. Go to Keyboard Shortcuts and look up "go to reference." I had it map it to Cmd-T in Jetbrains.
Map word jumping. I like to have word move mapped to Ctrl-Arrow instead of Option/Alt-Arrow. This requires changing some of the hotkeys around.
Move cursor to start/end of file. Known as the cursorBottom and cursorTop command. I map em to Ctrl-End and Ctrl-Home to match my PC keyboard muscle memory.
Move line up/down. Open keyboard shortcuts and search for "move down." In Rubymine, I had this set as "Cmd-Shift-Up|Down" so I setup VS Code to use the same.
Show current file in project view to Cmd- S. Open "Keyboard Shortcuts" and find the workbench.files.action.showActiveFileInExplorer action. Map it to Cmd-S. You can also click the link to existing mappings for Cmd-S (I had three of them) and remove those.
Symbol open dialog to Cmd-D. Open "Keyboard Shortcuts" and look up "Go to Symbol in Workspace." Set it to your preferred hotkey for looking up symbols (I believe Cmd-D is the Jetbrains default?)
Tab size. Search for "Tab size" to change the default tab size from 4 to 2 (seems to be applied globally across all files, unlike Jetbrains where there are many per-language settings for this)
Auto-close methods. In Rubymine, I appreciate the editor adding an "end" automatically when I declare a new class or method. Ruby LSP documentation claims "Completion for classes, modules, constants" as a feature, but hasn't worked for me yet.
Enable auto-save. For parity with Rubymine, files should be saved whenever the editor loses focus. If you look up "save" in the "Settings" input field, you should find "Auto save" as the top option.
CSS Peek. Allows "symbol lookup" to find CSS classes/IDs. I subsequently visited "CSS Peek Settings" and added "HAML" to the list of "CSS Peek: Peek from languages". TBD if that did anything.
Gitlens. Shows blame for each line when hovered, and is recommended by many. Haven't evaluated it in any detail on day 1.
Go to next change. I tried the default "Go to next change," I tried a couple GitLens actions that seemed to be designed to do this, but neither worked. Ultimately I found a Stack Overflow post that advised trying this extension, which has allowed me to map "F7" to go-to-next-scm-change which seems to be working like Rubymine.
Ruby LSP from Shopify. Seems to be necessary to run a "Language Server" that can locate Ruby methods upon triggering "Go to symbol."
As best I've been able to determine, this is entirely the provenance of the user's global settings.json file. By opening the Command Palette and choosing "settings.json", you can specify directories to be excluded from search:
You can also specify files.exclude:
The files.exclude setting completely hides files and folders from VS Code's interface. This affects both the File Explorer and all search operations. When you exclude a file or folder here, it won't appear anywhere in VS Code unless explicitly included through other settings.
Visual Studio Code, like Cursor, has quite the predilection for reformatting code on save. I suppose that in a more perfect world I might better memorialize our conventions in a lint config file that would reduce the degree of annoyance from these reformats. But it is time consuming to multiply 1,000 little pieces like my preference to have carry-over function parameters not align with the subsequent body of the method. So, an ongoing chore for getting up to speed in VS Code (and Cursor) has been figuring out how to prevent files getting automatically changed upon save.
There is a global option for "Format on Save" that can be modified within settings. That's the starting point. But from my experience, pretty much every language that the IDE operates on each have their own "Format on Save" setting. As such, after turning off the global "Format on Save," I then had to look up ruby save, javascript save and scss save to confirm each of those had "format on save" disabled. 😕
Cursor (and I believe the Copilot plugin in VS Code) allow the user to create files that contain content that will be often or always submitted to the LLM when it is generating code. In Cursor, you can invoke this by opening the Command Palette (Cmd-Shift-P) and entering "Settings" to pick Cursor Settings.
You'll be asked to name the rule, after which you'll be able to enter content that minimizes the boilerplate that needs to be submitted with each incremental chat interaction. Here is Bill's rule file after its first 10 minutes of life.
https://vscode.dev/editor/profile/github/1adede2e626691f32ec9393c10615df7
Different procedures to recreate functionality from Rubymine.
Option 1: Right-click folder and choose "Find in folder"
Option 2: Left-click the folder and press Shift-Option-F
After using Cmd-Shift-F to search, F4 (and Shift-F4) can be used to cycle through search results
Other suggestions by ChatGPT seem less excellent, like pressing tab a bunch of times
You don't need a blogger to tell you that there is no stable "best" LLM to trust for every programming problem. The LLMs arm race in 2025 is progressing at the light speed, for better and worse.
✌️