What's That One Config That Changed Your Life?

You've seen the thread. Someone asks: "What's that one $5 purchase that changed your life?"

The answers are always the same. A bidet. A phone stand. A better can opener. Small things. Embarrassingly cheap. Life before and after.

Developers have their own version. "What's that one config change that changed your life?"

The answers hit different when you've been doing it wrong for years:

"I added set -o vi to my shell and never looked back"
"I learned you can git stash -p and my life got 10x better"
"Turns out defaults write can disable Dock animations. I've been waiting for that bounce for a decade"
"I set HISTSIZE=100000 and suddenly I could actually find old commands"

The pattern is always the same. Someone discovers something small. It fixes friction they'd normalized. They wonder why nobody told them sooner.

The Discovery Problem

These life-changing configs exist. They're in blog posts, dotfiles repos, tweets from 2019. The problem isn't availability. It's fit.

That set -o vi tip? Useless if you don't know vi. Life-changing if you do.

That defaults write for faster animations? Irrelevant on a desktop. Essential on a laptop where you're switching spaces fifty times a day.

Generic lists fail because they can't know what you need. The config that changes your life depends on:

What you do daily
What tools you already use
What friction you've stopped noticing
What you didn't know was possible

This is why the best tips come from coworkers who watch you work. They see you do something the slow way. They wince. They share.

But most of us don't have someone watching our terminal.

AI as the Coworker Who Watches

LLMs can play this role. Not by guessing what you need. By asking.

The trick is structuring the conversation. An AI that says "here are 50 shell tips" is useless. An AI that says "show me your .zshrc and tell me what annoys you" is a consultant.

The difference is a prompt that encodes the process of discovery, not a list of solutions.

You are my macOS developer-environment quality-of-life engineer.

Your job:
- Inspect my current setup via whatever I paste or run for you.
- Propose improvements customized to *me specifically*.
- Call out risks, side effects, and how to undo changes.

Assumptions:
- You never run anything yourself; you only tell me what to run.
- If you're missing information, you *ask* instead of guessing.

This framing changes everything. The AI becomes curious, not prescriptive. It wants to understand before it recommends.

Phased Discovery

The best audits happen in phases. Each phase reveals context that shapes the next question.

Phase 1: Who are you?

What kind of work do you do? Frontend, backend, DevOps, ML? What editor? What do you care about: speed, battery life, simplicity, aesthetics? How aggressive are you willing to be with changes?

A frontend developer who values battery life gets different recommendations than a DevOps engineer who values speed.

Phase 2: What do you have?

Your .zshrc. Your $PATH. Your Homebrew packages. Your editor extensions.

This is archaeology. Layers of past decisions. Things you installed once and forgot. Configs you copied from a blog post in 2021.

Phase 3: What's actually happening?

What services are running? What's eating disk space? What's in your global gitconfig? What startup items are slowing your boot?

The gap between "what you think you have" and "what you actually have" is where the discoveries live.

Phase 4: What bothers you?

What do you wish was faster? What makes you reach for the mouse when you'd rather not? What error message do you see so often you've stopped reading it?

This surfaces the friction you've normalized. The stuff you'd fix if you remembered it was fixable.

The Scoring Trick

Raw recommendations aren't useful. You need prioritization.

For each suggestion, the AI should provide:

Impact score (1-5): How much will this actually change your day?
Effort score (1-5): How long will this take to implement?
Risk level: What could break? How do you undo it?

Sort by impact descending, effort ascending. Cheap big wins float to the top.

This is how you find the $5 purchases. High impact, low effort, easily reversible. The config equivalent of a better can opener.

What People Actually Find

When developers run this kind of audit, they discover patterns:

The forgotten alias. You have 47 aliases in your .zshrc. You use 3 of them. The rest are from a dotfiles repo you cloned four years ago.

The unknown default. Your terminal has settings you never changed because you didn't know they existed. Faster key repeat. Mouse reporting. Clickable URLs.

The outdated workaround. You're still doing something manually that a tool now handles. You're still avoiding a command that was fixed two versions ago.

The tool you forgot you installed. brew list shows things you don't recognize. Some are dependencies. Some are things you tried once and forgot. Some are things you should be using daily.

The friction you normalized. You've been hitting the same three keystrokes 50 times a day. An alias would save you 100 keystrokes daily. That's 36,500 keystrokes a year you didn't know you were wasting.

The Meta-Pattern

This prompt is a template. The structure works for any personalized technical audit:

Gather context before recommending
Phase the discovery to avoid overwhelm
Score for prioritization
Always include reversibility
Focus on fit, not best practices

The goal isn't to find the objectively best config. It's to find the config that changes your life.

Somewhere in your setup is a $5 purchase waiting to happen. A config change you'll wish you'd made years ago. A flag you didn't know existed. A default you never thought to question.

The friction you've stopped noticing is still friction.

An AI that asks the right questions can help you find it. But only if you let it look.

Why I Still Believe in Video

I've been producing videos on egghead for 12+ years (and YouTube older than that). I've watched tools come and go. I've seen hype cycles peak and crash.

Through all of it, one thing stayed constant: watching someone who's obsessed with a craft is the fastest way to absorb it. Not documentation. Not blog posts. Watching.

I've spent 20+ years hunting for quality-of-life hacks. The configs that save hours. The tools that remove friction. The workflows that let you focus on the work instead of fighting your environment.

AI changed everything. Not because it replaced that hunt, but because it accelerated it. The discoveries come faster now. The possibilities expanded.

That's what you'll find at dev.build: a continuous collection of life-changing tips, specifically focused on AI, from someone who can't stop looking for them.

The goal isn't productivity theater. It's rediscovering the joy of programming.

The tools got better. Your experience of using them should too.