What This Stack Does
VS Code is the default choice for most developers today, and for good reason — it has an enormous extension marketplace, excellent language support, and a familiar interface that gets the job done. But defaults deserve questioning. VS Code is an Electron app that routinely consumes 500MB to 2GB of RAM before you even open a file, and its dominance has created a monoculture where Cursor, Windsurf, Trae, and Void are all forks of the same codebase with the same underlying architecture and the same fundamental performance characteristics. When every "new" editor is just VS Code with an AI sidecar bolted on, you are not actually getting innovation — you are getting a reskin. This stack is for developers who want to break free from that monoculture entirely. Every tool here was chosen because it represents a genuinely different architectural decision, a different philosophy about how software should be built. The goal is not contrarianism for its own sake but rather a deliberate exploration of what becomes possible when you step outside the Electron-wrapped, extension-dependent, Microsoft-adjacent comfort zone that VS Code represents. You might discover that faster tools make you a faster developer, that fewer abstractions mean fewer bugs, and that the terminal is not a relic of the past but a superpower waiting to be reclaimed.
Two Editors, Zero Electron
Zed is the centerpiece of this stack and the primary answer to the question of what editing code looks like without VS Code. Built from scratch in Rust by the original creators of Atom (the editor that GitHub built before Microsoft acquired it and eventually sunset it in favor of VS Code), Zed uses a custom GPU-accelerated rendering framework called GPUI that bypasses the browser engine entirely. The result is an editor that opens in under 100 milliseconds, renders at native frame rates, and handles 100,000-line files without breaking a sweat. Zed includes built-in LSP support for intelligent code completion, Treesitter-based syntax highlighting that is both faster and more accurate than TextMate grammars, and native Git integration — all without installing a single extension. The collaboration features are built directly into the editor, allowing real-time pair programming with cursor tracking and voice chat through a simple shared link. Zed also ships with a built-in AI assistant panel that supports Claude, GPT, Ollama, and other providers, giving you AI-powered coding without needing to install Copilot or any extension. The extension ecosystem is growing through WASM-based plugins, and while it is smaller than VS Code's marketplace, the built-in feature set covers what most developers actually use extensions for.
Neovim fills the role that VS Code's integrated terminal pretends to fill — it is the editor you reach for when you are already in the terminal, when you are SSH'd into a remote server, when you are editing a config file inside a Docker container, or when you simply want to make a quick change without waiting for a GUI to launch. Neovim is not a compromise or a fallback; it is a precision instrument that, once configured, offers editing capabilities that no GUI editor can match. Modal editing — the paradigm where different keys do different things depending on whether you are in normal, insert, visual, or command mode — is initially bewildering but ultimately allows you to edit text at the speed of thought, composing operations like a language rather than memorizing keyboard shortcuts. With modern Lua-based configuration and plugins like Telescope, nvim-lspconfig, and Treesitter, Neovim provides intelligent code completion, fuzzy file finding, and syntax-aware editing that rivals any modern IDE. The key advantage over VS Code's terminal is that Neovim IS the terminal — there is no context switch, no overhead, no Electron wrapper between you and your code. It starts in milliseconds and uses a fraction of the memory.
AI and API Testing Without Extensions
Claude Code replaces every AI extension you have ever installed in VS Code — Copilot, Cline, Continue, Cody, and all the rest. Instead of living inside your editor as a sidebar panel that competes for screen real estate and adds to your RAM usage, Claude Code runs as a standalone CLI agent in your terminal. You invoke it, describe what you want, and it reads your codebase, writes code, creates files, runs commands, fixes errors, and commits changes — all without needing to be embedded in any specific editor. This architecture is fundamentally more powerful than an editor extension because Claude Code is editor-agnostic: it works the same whether you use Zed, Neovim, Emacs, or even nano. It has full access to your terminal environment, can run tests, interact with git, execute build commands, and iterate on its own output. Aider complements Claude Code as another terminal-based AI pair programmer with a different interaction model — Aider watches your git repository, integrates changes directly into your working tree, and provides a conversational interface optimized for iterative code changes. Having both gives you flexibility: Claude Code for larger autonomous tasks and Aider for interactive pair programming sessions.
Bruno replaces Postman and every API testing extension you might have used in VS Code, but with a philosophy that aligns perfectly with the anti-VS Code mindset. Bruno stores API collections as plain files in your git repository using a human-readable markup language called Bru. There is no cloud sync, no account required, no proprietary format — your API tests live right next to your code and go through the same version control, code review, and CI/CD pipeline as everything else. This is a radical departure from Postman, which locks your collections in a cloud account and has increasingly pushed users toward paid team plans. Bruno supports environments, scripting, assertions, and collection runners, covering the vast majority of what developers actually use Postman for. Ghostty rounds out the terminal side of this stack as a purpose-built terminal emulator written in Zig that focuses on correctness, performance, and modern terminal features. Ghostty renders text using GPU acceleration, supports ligatures and font features that most terminals struggle with, and handles Unicode correctly — including complex emoji and CJK characters. It is not just a replacement for VS Code's built-in terminal; it is categorically better than any terminal panel embedded in any editor.
The Bottom Line
What you gain from this stack is genuine independence, performance, and depth of understanding. Every tool here starts faster, uses less memory, and does its specific job better than the VS Code equivalent. You gain the ability to work on remote servers, in containers, and over SSH without shipping a 500MB Electron app to the other side. You gain resilience — if any single tool in this stack disappears tomorrow, the others continue working independently because they are not coupled through a shared extension runtime. You gain skills that transfer: modal editing, terminal proficiency, and CLI tool composition are capabilities that will serve you for decades regardless of which editors come and go. What you lose is convenience and ecosystem breadth. VS Code's marketplace has extensions for everything, and some specialized language tools or framework integrations simply do not exist outside that ecosystem yet. You lose the familiar single-window experience where editor, terminal, debugger, source control, and extensions all live under one roof. The learning curve is real — Neovim alone can take weeks to configure productively, and switching from a mouse-driven to a keyboard-driven workflow requires deliberate practice. But for developers who value performance, independence, and craftsmanship over convenience, this stack is not a sacrifice — it is a liberation.