When I started programming, learning my environment was the thing. Configuring vim. Writing shell scripts. Understanding how dotfiles worked. It was slow, but it was exhilarating. I spent my formative years in dreamweaver, vscode, and netbeans but I was breaking out of the shackles of the all inclusive IDE for a manicured space that was mine. It didn’t feel like a distraction—it felt like the point. Every tweak taught me something about how programs were glued together.

Then I had to get productive. I had customers. I had deadlines. I had managers. Shipping became the task. Wrestling with configs and bash scripts started to feel like toil. It was fun when I had the time, but often it was a long night or weekend that I would pay for out of the mental energy I had for meeting deadlines. Things stayed “good enough.” I had a mental list of improvements I’d make “someday,” but someday never came. Just little annoyances day in and day out that I would eventually get frustrated enough to fix.

AI changed that completely.

The playground is back

Scripts that used to take hours- figuring out what language they needed to be in, what package to use, debugging unfamiliar language syntax and paradigms, now take 5-10 minutes. The cognitive load of remembering bash vs. Python vs. jq disappeared—I describe what I want, iterate on the result, and move on.

My dev environment has become a playground again. Not because the tools got better (though they have), but because the cost of building exactly what I want finally dropped below the cost of tolerating what I have. The joy of tinkering is back, without the time tax and even better, I learn as I go. If I don’t understand something, I take the time to have the LLM elaborate and teach me. My environment is better than ever, I’m learning faster than ever, and I’m having the most fun I have had since probably college.

Example: Git aliases that fit my workflows

I work heavily in git. My old aliases were fine—the usual suspects like git co for checkout, git st for status. But they didn’t match how I actually work.

With AI, I rebuilt them in 15 minutes. Not just shortcuts, but workflows:

# Reset current branch to match remote (discards local commits/changes)
rr = "!f() { git fetch origin && git reset --hard origin/$(git branch --show-current); }; f"

# View what's on my branch vs master
lm = log master..HEAD --oneline
dm = diff master...HEAD --stat

# Check if a commit made it to a branch
ib = !sh -c 'git merge-base --is-ancestor $1 $2 && echo "✓ Commit $1 is in branch $2" || echo "✗ Commit $1 is NOT in branch $2"' -

The rr alias alone saved me multiple times this week. Before, I’d google “git reset to remote branch”, because I could never remember the exact incantation. I’d use it infrequently on specific projects, make an alias and forget what it was.

I made myself an aliases command that grabs the comment directly before the alias along with the alias itself. Now in a split second, I can refresh on the command I haven’t used in a while, and build the muscle memory.

# List all git aliases with their descriptions
 aliases = "!f() { sed -n '/^\\[alias\\]/,/^\\[/{/^\\[alias\\]/d;/^\\[/d;p;}' ~/.gitconfig | sed -E 's/^[[:space:]]*#(.*)$/\\x1b[90m#\\1\\x1b[0m/' | sed -E 's/^[[:space:]]*([a-z-]+)[[:space:]]*=/\\x1b[1;36m\\1\\x1b[0m =/'; }; f"

I also realized my aliases didn’t use a consistent naming scheme. I had Claude rework all of them based on the same rules.

ib = in-branch. rr = reset-remote.

Last, I realized I was spending so much time remembering git commands, I completely forgot that I had g aliased to git in zsh.

g rr g rom

More than productivity

This new LLM era isn’t about AI writing your code. It’s about getting back the joy of exploring and being curious that I lost. I get to invest in my tooling and receive those dividends every single day I open my computer.

AI handles the busywork, I actually have time to:

  1. Decide what I want - Think about my actual workflow, not just copy someone else’s
  2. Implement it - Without getting derailed by syntax
  3. Build muscle memory - Use it enough that it becomes automatic

It took me about 2 working days to completely retrain my Git muscle memory. I’ve done this for several other tools and workflows.

I am the happiest and most productive I’ve ever been. The limitation is my imagination.

If you have annoyances with your workflow, there has never been a better time to invest. Minor frustrations you have been tolerating for years can become 30-45 minute joyful explorations.

You might just find that the joy of tinkering—the thing that got you into programming in the first place—has been waiting for you.

My complete git aliases list

[alias]
 # === Commit Operations ===
 # Stage all changes and commit
 ac = !git add -A && git commit
 # Amend the last commit
 am = commit --amend

 # === Viewing Changes ===
 # View staged but not committed changes (diff cached)
 d = diff --cached
 # View file changes between current branch and master (diff master)
 dm = diff master...HEAD --stat

 # === Logs ===
 # View last commit with file stats
 l = log -1 --stat
 # Show log with full commit hashes (one line per commit) (log pretty)
 lp = log --pretty=oneline
 # Show log with short commit hashes (one line per commit) (log oneline)
 lo = log --oneline
 # View commit log of what's on current branch vs master (log master)
 lm = log master..HEAD --oneline

 # === Fetch & Sync ===
 # Fetch all remotes and prune deleted branches (fetch all prune)
 fap = fetch --all --prune
 # Fetch and rebase current branch on origin/master (rebase origin master)
 rom = !git fetch origin && git rebase origin/master

 # === Reset Operations ===
 # Reset current branch to match remote (discards local commits/changes) (reset remote)
 rr = "!f() { git fetch origin && git reset --hard origin/$(git branch --show-current); }; f"
 # Reset to a specific remote branch: git rb <branch-name> (reset branch)
 rb = "!f() { git fetch origin && git reset --hard origin/${1:-main}; }; f"

 # === Branch Operations ===
 # Show all branches (local and remote) containing a commit: git fc <commit-hash> (find commit)
 fc = branch -a --contains
 # Check if a commit is in a specific branch: git ib <commit-hash> <branch-name> (in branch)
 ib = \\!sh -c 'git merge-base --is-ancestor $1 $2 && echo \"✓ Commit $1 is in branch $2\" || echo \"✗ Commit $1 is NOT in branch $2\"' -

 # === Utility ===
 # List all git aliases with their descriptions
 aliases = "!f() { sed -n '/^\\[alias\\]/,/^\\[/{/^\\[alias\\]/d;/^\\[/d;p;}' ~/.gitconfig | sed -E 's/^[[:space:]]*#(.*)$/\\x1b[90m#\\1\\x1b[0m/' | sed -E 's/^[[:space:]]*([a-z-]+)[[:space:]]*=/\\x1b[1;36m\\1\\x1b[0m =/'; }; f"