Introduction
This post comes in two parts. The first is a rambling tangent about why I believe VS Code is a bad tool. Sorry. I have a lot of pent up frustration. The second part is genuine advice on configuring VS Code to force yourself to adopt a more keyboard centric workflow. That starts at this heading.
I’ve used many editors and IDEs over the years. Back when I was younger, maybe 13-16, I was very flexible. I used whatever I had and whatever I thought was cool. I grew up on Visual Studio (or Codecademy to be more accurate) because I made the unfortunate decision to learn C# as my first language. That led to many years of flirting with game development in Unity. I also did some light and unsuccessful engine development in IntelliJ (using Java, yes). I even wrote C in GNU Nano on laptops at my school. I flirted with Vim and Emacs during my Linux customisation phase.
Interestingly, the one editor which never interested me at all was Visual Studio Code. It felt like it was sitting in this awkward place between being feature light and an IDE. I just… wasn’t a fan. I think there was a very high chance I would’ve ended up a Neovim user if I was interested in development back when I was daily driving i3. Somehow though, I ended up a VS Code user and now I’m trapped:
- I need to switch back to Linux to do proper terminal centric development. It’s absolutely horrible on Windows.
- I need to dualboot Linux & Windows so I can pirate software and games (sorry not sorry).
- I need my only spare SSD to run my home server, and I need to not waste money on a new SSD.
Hence, I am stuck. However, I realised that what I’m doing to cope with VS Code would actually work well as a path to lift oneself out of VS Code dependency into a more keyboard centric workflow. First, let’s talk about why VS Code isn’t that great.
So much is wrong with VS Code
This is the part where I go on a rant.
Instability
Let’s move past the jokes about performance to make fun of VS Code in some new ways. It’s embarrassingly unstable. There are countless bugs only fixed by reloading the window (in extensions and Code itself). Extensions which I have no doubt are developed by incredibly smart people (e.g the Vim & rust-analyzer plugins) are plagued by persistent bugginess. It’s not hard to understand why. I don’t know how many of you have had the displeasure of interacting with the VS Code system for key bindings, but it’s arcane, mostly undocumented, and unbelievably verbose. It’s a good way to understand how hacked together VS Code is.
Working with VS Code is much about the least in control of my programming environment I’ve ever felt. In my experience, VS Code is really lovely if you want:
- A search all files menu that just seems to appear at any time it wants
- Schizophrenic Git integration that doesn’t really work at all with multiple accounts
- Code suggestions that disappear and don’t come back until you fully delete and retype a line
- LSP hallucinations that require an editor restart to fix
You get some bonus instability in the fact that fucking Microsoft owns your code editor. VS Code comes with a fun feature where it serves as a vertex of Microsoft’s ongoing and incredibly obvious plan to:
- Buy a popular VCS service.
- Capitalise on a gap in the market for free user-friendly editors by using their insane wealth to undermine competitors.
- Highly integrate that aforementioned VCS service with their editor to undermine their competitors.
- Use open source code with no consent to build an AI tool that is also highly integrated with your editor to undermine their competitors.
- Gradually vertically integrate the three until new developers do not know another way of developing but the ✨Microsoft Way✨.
Mediocrity abounds
VS Code displays my absolute least favourite kind of UX. It lives in this valley of mediocrity where the defaults are okay enough to convince you they aren’t worth changing, but they still handicap you. It’s barely good enough. It isn’t quite worth it to go through the key binds to work out what obscure value you have to change.
It’s an interesting balance. VS Code with minimal key binds and heavy mouse usage is just fast enough and configuring VS Code is just painful enough that most people never worry about optimising for productivity. Even if they did, optimising VS Code doesn’t get you far. I don’t blame Code users (like myself) for their mediocrity in using their editor. Who would ever bother with learning the key bind for find and replace when it functions identically to find but the replace dropdown is auto expanded? Why would you ever learn to open and switch between files with the keyboard if it takes an extension and multiple configuration options to barely suppress VS Code’s eagerness about re-opening its file explorer at any moment that is vaguely related to files? Invest too much time into the default set of VS Code key bindings, and you’ll come out with maybe 5-10 things that are useful, half of which everyone else knows anyway. VS Code’s interface isn’t just mediocre, its mediocrity encourages its users to accept the defaults, only learn a key bind when something is especially tedious, and live with that.
VS Code holds back developers from growth in this way. It does even more harm in the manner in which it obscures the processes underlying development.
Abstraction
VS Code serves to drag you away from the machine you’re communicating with into Microsoft land. VS Code is not just a code editor. It’s actually
a nearly fully featured file manager, a GUI git client, a debugging GUI, a terminal - three in fact, one of which supports tiling and tabs, a code linter, a fully featured Markdown editor including preview, document outline, and snippets. Oh, and it’s a code editor too! With tabs, tiling, tabbed tiling, that incomprehensible system where your open tabs depend on the file you have focused, and a bunch of other stupid bullshit related to moving editors around.
What actually makes this a problem though? Plenty of editors (read, IDEs) are like this. However, VS Code is not truly an IDE. It’s more like Sublime Text cosplaying a riced up Emacs config.
The difference is that those heavyweight IDEs actually achieve gains with their abstraction. Given that setting up a CMake build pipeline that actually works on more than 2.58% of computers is one of mankind’s greatest unsolved problems, it’s fine to put some extra bulk into a development environment. I would not expect an application that manages my entire toolchain and build process to play nice with a non-integrated terminal. The same goes for the file explorer, given the sheer weight of refactoring tools provided. Heavyweight IDEs like IntelliJ and Visual Studio are like aircraft carriers. They’re giant, slow, expensive, hard to maintain, and overkill for nearly any situation. Under this analogy, Visual Studio Code is more like a cruise ship: giant, slow, expensive, hard to maintain, and overkill for nearly any situation. The difference is that the aircraft carrier achieves something. The cruise ship serves to take tourists through the exotic world of “Jabmascript” hundreds of feet from the shore and distant from anything that might scare them.
| Abstraction | IDE Result | VS Code Result |
|---|---|---|
| Run & debug | Managed build pipeline | launch,json (???) |
| Integrated terminal | Readable output of IDE tasks | launch,json again??? |
| File explorer | Robust and flexible refactoring tools | I had to download a fucking extension to be able to create files without the goddamn stupid fucking file explorer and then another one to stop it from automatically popping up every single time I do anything. |
VS Code does all the abstractions for no particular reason. It just makes things less scary for those who want to be developers but are terrified of being left alone with a computer. It’s incredibly rare to have an editor which features both 3 kinds of integrated terminals (with multiple tabs, splits, and pop out terminals) and a userbase who would rather use the terminal to run projects over the built in tooling.
One could however point out that editors like Neovim and Emacs have the potential for and a history of custom tooling including file management, tooling, debugging, git, etc. There’s an absolutely crucial difference between abstractions you make and abstractions you learn. VS Code is all abstractions you learn. Instead of learning your way around your computer, you learn your way around VS Code land. When other people make abstractions and you simply learn them, you just warp reality. Building your own abstractions however is a powerful tool for creating understanding. It’s the difference between an abstraction that conceals and an abstraction that invites deeper understanding.
Basically
VS Code is an overbuilt editor which encourages mediocrity in its users, obscures the functioning of their computer from them with overzealous abstractions that bear no fruit, and serves as a key part of Microsoft’s blatant goal to establish a comfortable and intertwined monopoly over the most important parts of developer tooling. It is not a kindness from Microsoft, it is them creating the most milquetoast editor ever and then utilising their humongous amounts of money to become the primary point where new developers are onboarded in an attempt to own their souls.
Fuck Microsoft.