Dotfiles

EJ Fox Dotfiles Configuration

Personal terminal environment optimized for minimalist productivity and AI-enhanced workflows.

Overview

A comprehensive dotfiles configuration emphasizing geometric aesthetics, functional minimalism, and modern CLI tools. Built around the philosophy of distraction-free computing with intelligent automation.

Core Philosophy

• Geometric symbols throughout interface (◆ ◇ ○ ▪ ─)
• Theme-agnostic design (adapts to light/dark mode automatically)
• Zen mode for deep focus across all applications
• Modern CLI tools replacing legacy Unix commands
• AI integration for context-aware assistance

Shell Configuration

ZSH (.zshrc)

Primary shell configuration with modern enhancements:

Key Features:

• Oh My Zsh with Powerlevel10k prompt
• Ruby environment via rbenv (replaced RVM)
• Email workflow integration
• Modern CLI aliases (lsd, bat, dust, duf, btop)
• Lazy-loaded tools (conda, zoxide, atuin) for performance
• Smart git commit with LLM integration
• UV Python package management

Notable Aliases:

alias l='lsd -lah'           # Enhanced ls with icons
alias c='clear && refresh'   # Clear and refresh
alias m='neomutt'           # Email client
alias ei='email-insights'    # AI email analysis
alias commit='...'          # LLM-powered git commits

Startup Script (.startup.sh)

AI-powered Message of the Day system providing contextual information:

Components:

• Tasks - Integration with Things CLI
• Calendar - icalBuddy for today's events
• Recent Work - Git repositories from ~/code
• Recent Notes - Obsidian markdown files
• Email Summary - AI-filtered unread messages
• AI Insights - Personalized productivity suggestions (cached 3hr)

Intelligence Features:

• Filters out financial spam automatically
• Categorizes emails (🤖 dev, ⚠️ urgent, 📅 calendar)
• Skips in tmux sessions unless forced
• Background email sync
• Zen mode aware

Zen Mode (.zen-mode.sh)

System-wide minimal interface toggle:

• Hides menu bars and dock
• Disables notifications
• Creates `/tmp/.zen-mode-state` flag
• Integrates with tmux, nvim, and startup script

Terminal & Multiplexer

Tmux (.tmux.conf)

Minimalist terminal multiplexer configuration:

Visual Design:

• No colors (theme-agnostic)
• Geometric pane count indicators (⚌ ☰ ⚍ ⚏ ☷)
• Centered window list
• Subtle arrow indicators for active pane
• Prefix indicator: ◼ (when active)

Key Bindings:

Prefix: C-a
Windows: Alt+h/l (prev/next)
Panes: hjkl (vim-style)
Resize: HJKL (capital letters)
Split: - (horizontal), _ (vertical)

Email System

Neomutt + mbsync

Complete email workflow with AI enhancement:

Setup:

• mbsync for Gmail IMAP sync
• Neomutt as terminal email client
• Keychain integration for secure auth
• Background auto-sync

AI Features:

• Email subject filtering and cleanup
• Automatic categorization
• Spam/financial email removal
• Inbox insights and priority analysis
• Per-email AI summarization (Press 'S')

Workflow:

m           # Open neomutt
ei          # AI inbox analysis
1-4         # Quick filters (unread, replied, sent, flagged)
/           # Search
gg/G        # First/last email
S           # AI summarize current email

Development Environment

Neovim

LazyVim configuration with minimal aesthetics:

• Auto dark/light mode switching
• Zen mode integration
• Minimal statusline
• Hardtime plugin for vim skill building

Git Integration

• Smart commit messages via LLM
• Git status in sketchybar
• LFS support for large files
• Conventional commit formatting

Modern CLI Tools

Replacements for traditional Unix commands:

• lsd → ls (with icons and colors)
• bat → cat (syntax highlighting)
• dust → du (disk usage visualization)
• duf → df (disk free with graphs)
• btop → top (modern system monitor)
• zoxide → cd (smart directory jumping)
• atuin → history (encrypted shell history)

Application Configurations

Ghostty Terminal

Modern terminal emulator settings:

• Opacity and blur effects
• Font: SF Mono
• Theme synchronization
• Performance optimizations

Sketchybar

macOS menu bar replacement:

• Git status indicators
• Battery with percentage
• Productivity metrics
• Claude usage tracking
• Minimal aesthetic matching tmux

File Management

• Yazi - Terminal file manager without color distractions
• Btop - System monitor with transparent background

Automation & Intelligence

LLM Integration

AI enhancement throughout the system:

• Startup insights with CIPHER persona
• Email categorization and summarization
• Commit message generation
• Context-aware suggestions

Background Processes

• Email sync every 60 seconds
• Git status updates
• Theme synchronization
• Cache management (3-hour cycles)

Installation & Sync

Repository: https://github.com/ejfox/dotfiles

Setup Process:

git clone https://github.com/ejfox/dotfiles.git ~/.dotfiles
cd ~/.dotfiles
./sync-dotfiles.sh

Dependencies:

• Oh My Zsh + Powerlevel10k
• Homebrew packages (neomutt, mbsync, llm, etc.)
• LLM CLI tool with OpenAI API
• Things app for task management
• Obsidian for note-taking

Security Notes

• No secrets committed to repository
• Passwords stored in macOS Keychain
• App-specific passwords for Gmail
• Secure email authentication via keychain lookup commands

Recent Updates

Latest improvements include:

• Email system with AI filtering
• Rbenv migration from RVM
• Enhanced startup script with email integration
• Monochrome neomutt configuration
• Background sync automation
• Improved repo detection in startup

The Daily Workflow Field Guide

A survival manual for your future self when you inevitably forget how your own terminal works.

The Daily Workflow

When you open a terminal, your startup script automatically runs a custom dashboard that shows you everything you need to know right now. It pulls from Things for your tasks, icalBuddy for calendar events, scans your ~/code directory for recent git repos, checks Obsidian for recent notes, and gives you an AI-powered email summary that filters out all the financial spam automatically.

The AI (using your CIPHER persona) gives you cryptic but helpful daily insights cached for 3 hours. If you're in a tmux session, it won't spam you with this info unless you explicitly run `~/.startup.sh --force`.

Your Custom Commands

When you want to check email, just type `m` to open neomutt. Inside neomutt, press `1` to see only unread emails, `2` for emails you've replied to, `3` to jump to sent mail, `4` for flagged items, and `0` to show everything. If an email looks important but you don't want to read the whole thing, press `S` to get an AI summary.

For deeper email analysis when you have a pile of unread messages, run `ei` (email-insights). This feeds your recent email subjects to the AI and gives you a prioritized breakdown of what actually needs your attention versus what's just noise.

Your git workflow is enhanced with an AI-powered commit command. Just type `commit` and it'll analyze your staged changes, generate 10 different commit message options using conventional commit format, and let you pick one with fzf. No more staring at a blank commit message prompt.

Terminal Navigation

Your tmux setup is designed to be completely monochrome and distraction-free. The prefix key is `C-a` (not the default C-b). Use `Alt+h` and `Alt+l` to switch between windows quickly without hitting the prefix. For panes, it's pure vim: `hjkl` to navigate, `HJKL` (capital) to resize. Split with `-` for horizontal or `_` for vertical.

The status bar shows geometric symbols for pane counts: ⚌ for 2 panes, ☰ for 3, ⚍ for 4, etc. When you're using the prefix key, you'll see a ◼ indicator. The whole thing is centered like your code editor and completely theme-agnostic.

Zen Mode System

When you need deep focus, run `~/.zen-mode.sh` to hide the dock, menu bar, and disable notifications system-wide. This creates a `/tmp/.zen-mode-state` file that all your other tools check for. Your startup script won't show, tmux and nvim know to be extra minimal, and everything just gets out of your way. Run the script again to toggle back.

Email System Deep Dive

Your email setup is a three-part system: mbsync pulls from Gmail in the background, neomutt provides the interface, and AI processes everything to keep you sane.

The background sync happens automatically, but you can manually sync with `Ctrl+S` inside neomutt. Your startup script shows a smart summary that categorizes emails: 🤖 for dev notifications (GitHub, CI failures), ⚠️ for urgent items, 📅 for calendar stuff, and → for normal emails. Financial emails, payment failures, and subscription spam are automatically filtered out.

The AI email summarization happens in two places. The startup summary processes recent email subjects and cleans up encoding artifacts while filtering spam. The deeper `ei` command analyzes patterns in your inbox and suggests workflows for handling everything efficiently.

Inside neomutt, everything is monochrome to match your tmux aesthetic. No colors, just reverse highlighting for the current selection. Raw emails are shown in chronological order with no threading - pure and simple. Auto-mark-read is enabled so emails mark themselves read as you scroll past them.

Shell Customizations

Your zsh is heavily customized but loads fast through lazy loading. Tools like conda, zoxide, and atuin only initialize when you first use them. Your PATH prioritizes modern replacements: `lsd` instead of `ls`, `bat` instead of `cat`, `dust` instead of `du`.

The `c` command doesn't just clear the screen - it clears and runs your refresh function. The `l` command gives you a detailed directory listing with icons and human-readable sizes. When you want to jump directories, just type `z` followed by part of a path name - zoxide will figure out where you meant to go.

Your Ruby environment uses rbenv instead of RVM (you migrated away from RVM chaos). Python uses uv for everything - it's aliased to replace pip, pip3, python, and venv commands with helpful reminders to use uv instead.

Modern CLI Arsenal

You've replaced most traditional Unix commands with modern alternatives. `lsd` gives you colored ls output with file type icons. `bat` provides syntax highlighting when viewing files. `dust` shows disk usage visually instead of boring du output. `duf` presents disk free information with actual graphs. `btop` replaces top with a modern TUI that looks like a sci-fi interface.

These aren't just aliases - they're fundamental workflow changes. When you `cat` a code file, you get syntax highlighting automatically. When you `ls` a directory, you see file types at a glance. When you check disk usage, you get immediate visual understanding instead of scanning numbers.

Development Environment

Your nvim setup is LazyVim with minimal customizations. It auto-detects light/dark mode and switches themes accordingly. Zen mode integration means it goes completely minimal when you're in focus mode. The statusline is stripped down to essentials only.

Sketchybar replaces the default macOS menu bar with custom widgets. It shows git status for your current directory, battery percentage, and tracks how much you're using Claude API. Everything matches your minimal aesthetic - no flashy colors or animations.

The AI Integration Layer

Throughout your system, AI provides contextual assistance without being intrusive. The startup script uses your CIPHER persona to give daily insights. Email processing removes spam and categorizes everything intelligently. Git commits get smart suggestions based on your actual changes.

The key is that AI enhances your workflow without taking over. It filters noise, suggests actions, and provides context - but you're always in control. When the LLM is unavailable, everything falls back to sensible defaults.

File and Process Management

Yazi handles file management in the terminal with vim-like navigation but no distracting colors. Everything is about content and structure, not visual candy. Btop monitors system processes with transparency effects that integrate with your desktop.

For search, ripgrep (rg) handles text searching with blazing speed. The startup script uses it extensively to scan through your email and notes quickly.

Backup and Recovery

Your entire setup is version controlled in the dotfiles repo. The sync script handles symlinking everything to the right places. If you're setting up a new machine or recovering from a system wipe, just clone the repo and run the sync script.

All secrets are in macOS Keychain, never committed to git. Email authentication goes through keychain lookup commands. Your app passwords and API keys are safely stored in the system keychain and retrieved dynamically.

Troubleshooting Your Own System

If neomutt throws library errors, run `brew reinstall neomutt` to fix dependency issues. If the startup script seems slow, check if the AI reflection cache is stale - it's in `/tmp/startup_cache/reflection_cache.txt` and refreshes every 3 hours.

If email isn't syncing, manually run `mbsync gmail` to see error messages. The most common issue is keychain access - make sure your app password is stored correctly with the security command.

When tmux keybindings feel wrong, remember your prefix is `C-a`, not the default `C-b`. If you're getting weird characters in terminal output, check that your TERM variable is set to "xterm-256color".

The Philosophy in Practice

Everything in your setup follows the principle of minimal visual noise with maximum functional density. Colors are used sparingly and meaningfully. Animations are disabled. Information is presented geometrically and consistently across all tools.

The goal is a computing environment that stays out of your way but provides powerful capabilities when needed. AI handles the tedious filtering and categorization. Modern tools provide better UX than their Unix ancestors. Everything is designed for your future self to understand and maintain.

When you inevitably customize something new, follow the same principles: monochrome where possible, geometric symbols for status, intelligent defaults, and always provide a way to get back to baseline functionality.

The Meta-Philosophy: Why This Madness

Minimalism as Cognitive Offloading

Your setup isn't minimal for aesthetic reasons - it's minimal because every visual element that isn't essential is cognitive load. When you're deep in code or writing, your brain shouldn't be parsing bright colors, processing animations, or filtering visual noise. The monochrome approach across tmux, neomutt, and your terminal isn't about looking cool - it's about keeping your visual cortex available for the actual work.

The geometric symbols (◆ ◇ ○ ▪) aren't decoration. They're information dense and instantly recognizable without language processing. Your brain can distinguish between ◆ (task) and ◇ (repo) faster than it can read "Task:" and "Repository:". The symbols create a visual vocabulary that operates below conscious thought.

Automation as Anxiety Reduction

The AI integration throughout your system serves a specific psychological function: it handles the anxiety-inducing task of triage. Email anxiety comes from not knowing what's important in the pile. Your AI filtering removes that uncertainty by automatically categorizing and surfacing what actually needs attention.

The startup script's daily dashboard prevents the morning anxiety spiral of "what did I forget to do?" by presenting a complete contextual picture immediately. You don't have to remember to check Things, or icalBuddy, or scan your recent repos - the system remembers for you and presents it as a unified briefing.

Immediacy Over Perfection

Your shortcuts and aliases prioritize immediate access over complete functionality. `m` for email, `c` for clear-and-refresh, `ei` for email insights - these aren't trying to be comprehensive commands. They're muscle memory shortcuts for the 80% use case. When you need the full power of neomutt or a complex git operation, you can still access it, but the common actions happen with minimal keystrokes.

This extends to the AI commit messages. The goal isn't perfect commit messages - it's removing the friction of writing commit messages so you actually commit more frequently. Small, frequent commits with "good enough" messages are better than perfect commits that never happen because writing them is annoying.

Theme Agnosticism as Future-Proofing

Your monochrome approach isn't just about minimalism - it's about sustainability. Color themes go out of style. Dark mode and light mode preferences change. New operating systems introduce new design languages. By building everything around geometric shapes and reverse highlighting instead of specific colors, your setup remains functional and coherent regardless of the underlying theme.

When macOS introduces some new design paradigm in three years, your tmux will still look intentional. When you switch between light and dark mode, everything still works visually. You've decoupled your information architecture from the aesthetic fashions of the moment.

Intelligence at the Edges

The AI integration follows a specific principle: smart filtering and summarization, but human decision-making. The system never makes choices for you - it presents better information so you can make better choices. Email gets categorized and filtered, but you still decide what to read. Git commit messages get suggested, but you pick which one to use.

This prevents the learned helplessness that comes from over-automation. You remain in control of your tools rather than becoming dependent on them. The AI handles the tedious work of pattern recognition and information processing, but the creative and decision-making work stays human.

Mechanical Sympathy for Digital Tools

Your approach treats software like physical tools that need maintenance and understanding. Just as a craftsperson knows their tools intimately, you've configured your digital environment to be predictable, maintainable, and extensible. Every customization has a clear purpose and can be easily modified or removed.

The symlink approach to dotfiles, the keychain-based authentication, the modular AI components - these aren't just technical choices. They reflect a philosophy that your computing environment should be something you understand and control, not a black box that occasionally breaks in mysterious ways.

Sustainable Productivity

The entire system is designed around the recognition that productivity isn't about working harder - it's about reducing friction for the work that matters. Every automation, every shortcut, every piece of AI integration serves the goal of getting repetitive or anxiety-inducing tasks out of your way so you can focus on creative and analytical work.

The zen mode system acknowledges that sometimes the productivity system itself becomes a distraction. When you need deep focus, everything gets out of the way. The tools are there when you need them, invisible when you don't.

Preparedness for Cognitive Shifts

Your documentation approach (like this field guide) acknowledges that you won't always remember why you made certain choices. Future you might have different priorities, different cognitive patterns, or simply different muscle memory. By documenting not just what each piece does but why it exists and how it fits into the broader philosophy, you're giving your future self the context needed to modify the system intelligently rather than just breaking things.

The setup is designed to be understandable by someone who thinks like you but doesn't remember the specific decisions. It's cognitive continuity across time.

Technology as Extension of Thought

Ultimately, your dotfiles configuration treats your computing environment as an extension of your cognitive processes. The terminal isn't just a tool you use - it's part of how you think about problems. The AI integration isn't separate from your intelligence - it's an extension that handles the pattern matching and information filtering that your brain would otherwise have to do manually.

This is why the aesthetic choices matter as much as the functional ones. A cluttered, inconsistent, or unpredictable interface creates cognitive friction. A clean, consistent, predictable interface becomes transparent, letting you focus on the actual work rather than the meta-work of managing your tools.

The geometric minimalism, the AI filtering, the keyboard-driven workflows, the monochrome aesthetic - these aren't separate features. They're all part of creating a computing environment that amplifies human intelligence rather than competing with it for attention.

---