Tools I Use Daily as a CS Student

There are a thousand "my dev setup" lists, and most of them are aspirational — tools the author installed once and never opened again. This is the opposite: only the things I genuinely reach for every day, and the one rule I use to decide what stays.

The one rule

Before a tool earns a place in my daily workflow, it has to clear a single bar: does it still save me time after the novelty wears off? Plenty of tools are exciting for a week. The ones below survived months of ordinary, unglamorous use. If something needs constant fiddling to stay useful, it loses to the boring thing that just works.

The terminal is home

I live in the terminal, so the small tools that make it faster matter the most.

• A fuzzy finder (fzf). The single highest-leverage tool I use. Fuzzy-finding files, command history, and git branches turns "where was that?" into two keystrokes. Once it's wired into your shell, going back feels like losing a sense.
• A better cd (zoxide). It learns the directories I actually visit and jumps me there by a fragment of the name. Tiny, but I use it hundreds of times a day.
• A faster grep (ripgrep). Searching a whole codebase in milliseconds changes how you explore unfamiliar code. It's also the backbone of search inside my editor.
• tmux. Persistent sessions mean my layout survives a disconnect, and on a remote server it's the difference between "my work is gone" and "pick up exactly where I left off."

Editor

I use Neovim as my daily driver, but I want to be clear about why — and it's not the reason people assume.

It isn't about looking like a hacker or shaving milliseconds. It's that a keyboard-driven, modal editor keeps my hands in one place and my attention on the code instead of the cursor. The investment is real and the learning curve is steep; I wouldn't push it on anyone who's fighting it. The best editor is the one that disappears while you work — for some people that's VS Code, and that's a completely valid answer.

Tooling is personal. Copying someone else's setup wholesale usually gives you their friction without their reasons.

Git, used deliberately

Everyone uses git; fewer use it on purpose. The habits that actually help:

• Small, atomic commits with messages that explain why, not what. The diff already says what changed.
• Branch per piece of work, even solo. It keeps half-finished ideas from contaminating something that works.
• git log and git diff as reading tools. Most of my git time is spent understanding history, not writing it.

Things deliberately kept simple

I run plain, well-documented databases locally instead of elaborate setups. I keep a single notes file instead of a knowledge-management cathedral. I reach for the standard library before a dependency. Every one of these is a choice to spend my attention on the problem rather than the tooling around it.

The actual takeaway

The specific tools matter less than the principle: optimize for the operations you repeat hundreds of times a day, and ignore the rest. A fuzzy finder I use constantly is worth more than a beautiful dashboard I open twice a month. Audit where your time actually goes, sharpen those few things, and let the rest stay boring.