What Switching to Arch Linux Taught Me

After five years of full-stack work on a Mac, I switched my main machine to Arch and finally learned what my environment actually does.

I've been a full-stack developer for five years. I work in Next.js, TypeScript, React. I build things for a living. And until a few months ago, I was scared of my own terminal.

Not scared in an obvious way. I used it constantly. git commit, npm run dev, cd into directories. The usual. But I was using it like a vending machine. Punch in the known command, get the known output, move on. I had no real idea what was happening underneath, and I wasn't curious enough to find out.

Then I installed Arch Linux on my main machine.

Why Arch

I didn't do this because I needed to. My setup worked. MacOS is a perfectly good development environment. I did it because I was bored and a little restless, and because I kept running into developers online who talked about their Linux setups with this specific kind of enthusiasm. Not the "Linux is better" tribalism, but something more like genuine delight. Like they'd found a secret.

Arch Linux has a reputation. You install it from a bare terminal prompt, partition your own disks, configure your own bootloader, build up from nothing. There's no installer GUI holding your hand. The Arch Wiki is famously comprehensive and almost aggressively assumes you want to understand what you're doing.

The install was slower than a guided installer, but every step was something I actually had to understand instead of clicking "Next." That was the point.

The Tiling Window Manager Rabbit Hole

Once I had Arch running, I installed Hyprland and started configuring it from scratch. If you've never used a tiling window manager, the concept is simple: windows don't float. They tile. Every window gets a slot. You move between them with keyboard shortcuts. The mouse becomes optional.

This sounds annoying. It is, for about three days. Then something clicks.

When every action has a keyboard shortcut, you stop context-switching. Your hands stay on the keys. Your brain stops tracking where the mouse is.

I ran my own Hyprland config for about two weeks. It worked, but configuring everything yourself is its own job. Status bar styling, lock screen behavior, media keys, notification daemon, idle handling. Every session there was something small pulling me away from real work to go fix.

That's when I came across Omarchy, an opinionated Arch-based distro built around Hyprland with the rough edges already smoothed out. Sensible defaults. Integrations that work out of the box. I switched and got back the time I'd been losing to config.

I don't think tiling window management makes anyone a better developer in any measurable sense. But going through that two-week stretch of configuring everything by hand forced me to be intentional about my environment in a way I hadn't been before. I stopped accepting defaults. I started asking why things worked the way they did.

That question, why does this work this way, turned out to be the whole point.

What the Terminal Actually Is

Here's what I didn't understand before: the terminal is not a worse version of a GUI. It's a different tool with different strengths. The GUI is optimized for discoverability. You can find things by looking. The terminal is optimized for composition. You can chain things together, script them, repeat them exactly.

Once I started treating it that way, everything changed.

I started reading man pages instead of immediately Googling. I learned what flags actually do. I started writing small shell scripts for things I did repeatedly. I got comfortable with tmux for session management. I stopped closing my terminal windows.

The terminal rewards investment in a way that most tools don't. The more you put in, the more it gives back.

The Automation That Actually Stuck

The thing I'm most pleased with is simple. Almost embarrassingly simple.

I built a dev command. When I run dev micahshu.com from anywhere on my machine, it:

1. Opens a terminal running the dev server
2. Opens a terminal with Vim ready to edit
3. Opens Lazygit for version control
4. Opens a browser to localhost:3000

One command. Everything I need to start working is in front of me in about two seconds.

Here's roughly what that looks like:

#!/bin/bash
 
PROJECT=$1
 
case $PROJECT in
  micahshu.com)
    PROJECT_DIR="$HOME/projects/micahshu"
    PORT=3000
    START_CMD="npm run dev"
    ;;
  # add more projects here
  *)
    echo "Unknown project: $PROJECT"
    exit 1
    ;;
esac
 
# Launch terminals (adjust for your terminal emulator)
kitty --detach --directory "$PROJECT_DIR" -- bash -c "$START_CMD; exec bash"
kitty --detach --directory "$PROJECT_DIR" -- vim .
kitty --detach --directory "$PROJECT_DIR" -- lazygit
 
# Give the server a moment to start
sleep 2
xdg-open "http://localhost:$PORT"

Before this, I was opening things manually every single time. Terminal here, browser there, git client somewhere else. It sounds minor. It adds up.

The script isn't clever. It doesn't need to be. It just does what I always did, automatically, without me thinking about it.

Lazygit

I want to say something specific about Lazygit, because it changed how I use git.

I knew git. I used it every day. But I was using maybe 20% of it. Commit, push, pull, branch, merge. The stuff I needed to not lose work. The rest of it I did rarely and carefully, because I was never confident I understood what I was doing. Interactive rebasing, cherry-picking, stashing, resetting.

Lazygit is a terminal UI for git. It gives you a visual interface without leaving the terminal. You can see your branches, your diff, your stash, your log, all at once. And because everything is a keyboard shortcut, you start using features you never bothered with before.

I now do interactive rebases regularly. I cherry-pick commits between branches without hesitation. I use stash constantly. None of this required learning new concepts. I knew what these things were. Lazygit just made them fast enough to be worth doing.

# Install on Arch
sudo pacman -S lazygit

# Or on Mac
brew install lazygit

Run it inside any git repo. That's it.

Vim

I'm not going to tell you to switch to Vim. That's not the point.

What I'll say is that learning Vim's modal editing, even partially, changed how I think about text manipulation. The idea that you have a "normal mode" for navigating and operating on text, and an "insert mode" for actually typing, felt backwards for about a week. Then it started to feel obviously correct.

I'm not fast in Vim yet. I still reach for VS Code for anything complex. But I understand now why people who are good at Vim are really good at it. The ceiling is high. The concepts transfer.

I use Neovim with a minimal config. I'm not deep in the plugin ecosystem. That's a rabbit hole I'm not ready for.

What I Actually Learned

The Linux experiment wasn't really about Linux. It was about learning how my environment works instead of just using it.

Five years in, it's easy to stop questioning things. You have a setup that works. You have muscle memory. Changing anything has a cost. So you don't change anything.

Installing Arch forced me to build everything from scratch. I had to understand each piece before I could use it. And in doing that, I found a lot of things that were better than what I'd been doing. Not because they were newer or more popular, but because I'd actually thought about them.

The dev command is a small example. Lazygit is another. There are a dozen more.

The best tools aren't always the ones with the most features. They're the ones you've actually configured for how you work.

If you're a developer who's been on Mac or Windows for years and you've never really dug into your terminal, I'm not saying switch to Linux. I'm saying the curiosity is worth following. Pick one thing you do manually every day and ask whether it could be a script. Read the man page for a command you use constantly. Try Lazygit for a week.

You might not break anything. But you might learn something.

If you've been on Mac or Windows for years and you're starting to wonder what's under the hood, I'd love to hear what you find.