Understanding why a lightweight editor from Microsoft became the industry standard
By the late 2000s, a shift was happening in development tooling. While I was working primarily in Visual Studio, a new category of editors was emerging: Sublime Text 2, Atom, and others that prioritised speed and simplicity over comprehensive features. These tools targeted a specific need—developers who wanted something more capable than basic text editors but lighter than full IDEs.
The audience was primarily frontend developers and JavaScript enthusiasts who needed quick, responsive editing without the overhead of traditional IDEs. Opening a CSS file shouldn't require waiting for a full development environment to initialise.
Sublime Text 2 was particularly impressive. Fast, visually clean, and extensible through plugins. I used it for quick edits outside of C# work, and the responsiveness was noticeable. The limitation was that configuring it for anything beyond web development required significant effort.
Then Microsoft entered this space with something unexpected.
Visual Studio Code: A Different Approach from Microsoft
In 2015, Microsoft released Visual Studio Code. The name created some confusion with Visual Studio proper, but the product itself addressed a genuine gap in the market.
Built on Electron, VS Code achieved a balance that many thought impossible: responsive enough to feel lightweight, feature-rich enough for substantial work, and free. The decision to make it open source and cross-platform signalled a significant shift in Microsoft's approach to developer tools.
The extension ecosystem became the defining feature. Unlike some editors with complex configuration requirements, VS Code extensions were discoverable through an integrated marketplace and installed with a single click. Python support, TypeScript (built-in), language servers for virtually any language—the ecosystem grew rapidly and maintained reasonable quality standards.
C# Development: Bridging the Gap
For .NET developers, VS Code presented an interesting option. Microsoft had been open-sourcing .NET components, making cross-platform C# development viable. However, the debugging experience—critical for serious development work—remained more limited outside of Visual Studio.
VS Code with the C# extension (and later the C# Dev Kit) provided a functional C# development experience. Not equivalent to Visual Studio's polish, but sufficient for many scenarios. The ability to develop .NET applications on macOS or Linux opened possibilities that hadn't existed before.
The .NET experience in VS Code has improved substantially over the years. The C# Dev Kit extension brought solution-level features, better IntelliSense, and improved debugging. For developers who can't or won't use Windows, it's become a credible option.
AI Integration: The Current Focus
VS Code has become Microsoft's primary platform for AI-assisted development features. GitHub Copilot integration is most mature here, with features that continue to expand. The experience ranges from genuinely useful code completion to suggestions that require careful review.
This matters because the competitive landscape is shifting. Tools like Cursor are building AI-first editing experiences, and Microsoft is responding by deepening AI integration in VS Code. The results are mixed but improving, and the pace of development suggests this will remain a focus area.
Where VS Code Fits in Practice
VS Code has earned a specific role in my workflow:
- Configuration files: JSON, YAML, environment files—VS Code handles these cleanly
- Quick edits: When I need to modify something without loading a full project
- Multi-language work: Projects that span languages benefit from VS Code's consistent experience
- Cross-platform consistency: The same editor works identically on Windows, macOS, and Linux
However, for substantial .NET development, I still prefer Visual Studio. The debugging experience, IntelliSense depth, and project system integration remain stronger. VS Code is capable, but Visual Studio is specialised.
What VS Code Gets Right
Performance: Startup is fast. Opening files is fast. The responsiveness makes it suitable for quick tasks without the overhead of a full IDE.
Extension Quality: The marketplace has matured. Popular extensions are well-maintained, and the extension API is capable enough for sophisticated tooling.
Cross-Platform: Genuine platform parity. The experience on Windows, macOS, and Linux is consistent.
Free and Open Source: No licensing concerns, active community development, and transparency about direction.
What VS Code Gets Wrong
Electron Overhead: Despite being "lightweight," VS Code still consumes more resources than native editors. For developers on constrained hardware, this matters.
Configuration Complexity: Settings are powerful but can become complex. The JSON-based configuration is flexible but less discoverable than visual preference panes.
Not Quite an IDE: For complex projects requiring deep tooling integration—heavy refactoring, sophisticated debugging, comprehensive testing—VS Code requires extensions that don't always match integrated IDE features.
The Significance
The most notable aspect of VS Code isn't just that it's good—it's that Microsoft built it. The company pivoted from closed, Windows-only tooling to an open-source, cross-platform editor that developers across ecosystems adopted. It demonstrated that Microsoft could compete on merit rather than platform lock-in.
VS Code found its niche: fast enough for quick edits, powerful enough for real work, extensible enough to adapt to different workflows. It's not always the best choice for every task, but it's rarely the wrong choice.
For many developers, it's become the default. That's a significant achievement.
Next: Part 3 - JetBrains Rider and Neovim: When the mainstream options aren't quite right