I rebuilt my development setup recently. Not because anything was broken, but because I'd accumulated cruft—plugins I never used, shortcuts I'd forgotten, tools that solved problems I no longer had.
Starting fresh made me think about why I use what I use. Not just the tools themselves, but the principles behind the choices.
If you've seen my /uses page, you know the specifics. This post is about the reasoning.
Speed is a feature
Every millisecond of latency compounds.
A slow editor startup means you hesitate before opening files. A sluggish terminal means you batch commands instead of iterating. A heavy IDE means you avoid exploration because spinning up a new workspace feels expensive.
I've watched senior engineers work. The fast ones don't think faster—they execute faster. The gap between "I should check this" and actually checking it is nearly zero.
That's why VS Code over a full IDE. Why Neovim for quick edits. Why iTerm2 with a hotkey window that appears instantly with Option+Space.
The tools should disappear. When I think "open that file," my hands should already be doing it. When I think "search the codebase," results should appear before I finish the thought.
Speed isn't about rushing. It's about removing barriers between intention and action.
Simplicity reduces friction
I used to add tools constantly. Every "Top 10 Developer Tools" article sent me down a rabbit hole. My setup became a Frankenstein's monster of plugins, scripts, and configurations.
Then I started asking: What would I lose if I removed this?
The answer, surprisingly often, was "nothing."
Now I optimize for removal. If a tool requires maintenance, configuration, or mental overhead, it needs to justify its existence. The bar is high.
My VS Code has maybe eight extensions. My shell has a handful of custom aliases. My terminal config is under a hundred lines.
Less is not laziness. Less is discipline. Every tool you don't run is a tool that can't break, can't slow you down, can't distract you with notifications or updates.
Simplicity compounds just like speed does. A clean setup is a setup you actually understand.
Keyboards beat mice
I track time occasionally. Not religiously, but enough to notice patterns.
One pattern: mouse usage correlates with distraction.
When I'm in flow, my hands are on the keyboard. When I'm reaching for the mouse, it's usually because I'm lost—clicking around looking for something I should know the shortcut for.
So I invest in keyboard shortcuts. Not just learning existing ones, but building muscle memory until they're unconscious.
Some examples from my setup:
- Raycast (Option+Space) replaces Spotlight, clipboard history, and window management. One launcher for everything.
- VS Code Vim extension means my editing keystrokes are the same everywhere—same muscle memory in VS Code, Neovim, or any terminal.
- iTerm2 hotkey window summons a terminal from any app without touching the dock.
- Arc's command bar (Cmd+T) finds tabs, bookmarks, and actions faster than clicking through a UI.
The upfront cost is real. Learning shortcuts takes time. Building muscle memory requires repetition.
But the payoff is permanent. Once a shortcut is automatic, it's faster than any UI could ever be. Your brain thinks it, your hands do it. No visual scanning, no cursor targeting, no clicking.
Tools should evolve, not accumulate
My setup looks different than it did a year ago. It'll look different a year from now.
That's not inconsistency—it's growth. The problems I solve change. The available tools change. My preferences change.
The key is evolution, not accumulation.
Accumulation is easy. Something looks cool, you install it. Now it's part of your setup forever because uninstalling feels like losing something.
Evolution is harder. It means regularly asking: Is this still serving me? It means being willing to drop tools that once felt essential.
Some evolutions from my recent history:
- Starship replaced powerlevel10k as my prompt. Same information, faster rendering, works across shells.
- Claude replaced ChatGPT as my primary AI assistant. Better at nuance, larger context window.
- Linear replaced Notion for project tracking. More opinionated, less configuration, faster to use.
- Arc replaced Chrome as my main browser. Spaces changed how I think about context switching.
None of these were forced changes. The old tools worked fine. But the new ones worked better for how I work now.
The worst thing you can do is freeze your setup because "it's working." Working isn't the same as optimal.
Specific choices, specific reasons
Let me get concrete. Here's why some of my /uses page choices exist:
VS Code over Neovim full-time: I know Vim well enough to be dangerous. But VS Code's extension ecosystem, debugging tools, and Git integration save me more time than the raw speed of Neovim. I use Neovim for quick edits and when VS Code would be overkill.
Raycast over Alfred: Both are great launchers. Raycast's built-in window management and clipboard history meant I could remove separate apps for those features. Fewer apps = simpler setup.
TypeScript over JavaScript: Types are documentation the compiler enforces. The overhead of adding types is far smaller than the overhead of debugging type-related bugs in production. I catch entire categories of errors at compile time now.
Tailwind over CSS-in-JS: I used to write styled-components for everything. Tailwind felt weird at first—classnames full of utility values? But the consistency it enforces (spacing scales, color palettes) made my UIs more cohesive. And the build-time purging means tiny bundles.
Obsidian over Notion: Notion is slick. But my notes are markdown files on my disk. I own them. They'll outlast any SaaS company. And the local-first approach is instant—no loading spinners, no network latency.
These aren't universal recommendations. They're my recommendations for my problems. Your problems are different.
How to think about your own setup
If you're building or refining your setup, here's what I'd ask yourself:
What slows you down? Time yourself for a day. Where do you wait? Where do you repeat yourself? Where do you get frustrated? Those are the places to fix.
What do you actually use? Audit your tools. When did you last use each one? If something's been sitting idle for months, remove it.
What requires maintenance? Some tools need constant tending—configuration updates, plugin conflicts, breaking changes. Is the tool worth the upkeep?
What's muscle memory vs. what's just installed? If you have to think about how to use a tool, you're not really using it. Either invest in learning it properly or drop it.
The goal isn't to copy someone else's setup. The goal is to build a setup that disappears—one where the tools are invisible and all that's left is your thinking and your output.
The meta-lesson
The tools don't matter as much as you think.
I've seen great engineers with minimal setups and average engineers with elaborate ones. The tools are multipliers. They amplify what's already there.
What matters is:
- Understanding your tools. Knowing them deeply enough to use them without thinking.
- Maintaining your tools. Keeping them simple enough that maintenance is trivial.
- Evolving your tools. Being willing to change when something better emerges.
The best setup is the one you don't notice. The one that stays out of your way.
That's what I'm aiming for. Check back in a year—it'll probably look different.