I Ditched VS Code for a Terminal. My RAM Thanked Me.

My VS Code setup used to eat 4GB of RAM before I even opened a file. Extensions, integrated terminal, GitHub Copilot, a couple of preview panes -- and suddenly my MacBook fan sounds like it's preparing for takeoff. I lived with it for years because, well, what's the alternative?

Turns out, the alternative is better than I expected.

The Shift Nobody Predicted

Here's what changed: I stopped writing most of my code. Not because I quit programming -- because AI agents started writing it for me. Between Claude Code, Cursor's Composer, and Codex, my job shifted from "person who types code" to "person who reads code and decides if it's right."

And once you realize you're spending 80% of your time reading, reviewing, and navigating -- not editing -- the question becomes: do I really need a full IDE for that?

The honest answer is no. A heavyweight IDE makes sense when editing is your primary activity. When your primary activity is running agents, reading their output, and browsing files to verify changes, a terminal does the job with a fraction of the resources.

The Setup

I've been running this stack for about two months now, and I'm not going back.

cmux -- The Terminal Multiplexer for Agent Workflows

What makes it different from tmux or iTerm2 splits:

• Notification rings -- each pane shows a blue highlight when the agent needs your attention. When you're running three Claude Code instances in parallel, this is a lifesaver.
• Sidebar with context -- shows git branch, working directory, and listening ports for each workspace. No more guessing which pane is which.
• Built-in browser pane -- agents can interact with web UIs without you switching to Chrome.

brew tap manaflow-ai/cmux
brew install --cask cmux

I typically run 3-4 Claude Code sessions simultaneously -- one for the main feature, one for tests, one investigating a bug. cmux makes it possible to track all of them without losing your mind.

yazi -- A File Explorer That Doesn't Suck

The biggest thing I missed from VS Code was the file sidebar. Clicking around a project tree is second nature. In the terminal, you're stuck with ls and cd and hoping you remember where that config file lives.

What sold me:

• Image and code preview -- syntax-highlighted code previews right in the terminal. You can browse your project and preview files without opening them.
• Vim-style navigation -- h/j/k/l to move, enter to open, q to quit. No learning curve if you know vim.
• Bulk operations -- select multiple files, rename in batch, move, delete. Things that require a mouse in VS Code are keyboard shortcuts here.
• Tabs -- multiple directories open at once, just like browser tabs.

I keep yazi open in one cmux pane at all times. It's replaced the VS Code sidebar entirely.

glow -- Markdown Without a Browser

When agents generate documentation or you need to review a README, you don't want to open a browser or a preview pane. glow renders markdown beautifully in the terminal. Headers, code blocks, tables, links -- all formatted and readable.

glow README.md

Simple, fast, and one less reason to leave the terminal.

ripgrep -- You Already Know This One

In a terminal-first workflow, rg becomes your primary code navigation tool. Forget "Go to Definition" -- just rg "functionName" and you're there.

rg "handlePayment" --type ts -C 3

With context lines, you get enough surrounding code to understand the match without opening the file. For quick code review of agent output, this is often all you need.

neovim -- When You Actually Need to Edit

Sometimes you do need to edit a file manually. A quick config change, a one-line fix the agent got wrong, or a commit message. For that, neovim is already in your terminal. No need to launch a separate application.

I'm not suggesting you become a vim power user. A minimal config with syntax highlighting and basic LSP support is enough. The point isn't to replicate VS Code in the terminal -- it's to have a capable editor available when you need it, without the overhead when you don't.

The Resource Difference

Here's what my typical development session looks like in terms of memory:

• VS Code: ~2-3GB
• Extensions (ESLint, Prettier, GitLens, Copilot, etc.): ~800MB
• Integrated terminal: ~200MB
• Chrome for docs: ~1-2GB
• Total: 4-6GB

• cmux: ~150MB
• 3x Claude Code sessions: ~300MB each (~900MB total)
• yazi, glow, ripgrep: negligible
• Total: ~1.1GB

That's a 4-5x reduction. On a 16GB MacBook, that difference means the machine stays responsive instead of crawling. Fans stay quiet. Battery lasts longer.

Who This Isn't For

I want to be clear: this isn't a "VS Code is dead" take. If you're doing heavy frontend work with hot module reloading, debugging React components with breakpoints, or using VS Code's integrated test runners -- the IDE is still the better tool.

This setup works best when your workflow is:

If that describes your day, you're paying a massive resource tax for features you're not using. The terminal gives you everything you actually need at a fraction of the cost.

Getting Started

If you want to try this without fully committing, start small:

Don't try to replicate your entire VS Code setup. That's the trap. Instead, notice which IDE features you actually use during an agent-driven session. You might be surprised how few there are.

The tools have changed. The workflow has changed. Maybe the development environment should too.