haas on saas

← back to writing

Building a Developer Environment That Actually Works: My Dotfiles Journey

• 4 min read

A deep dive into creating a productive, AI-enhanced development environment with dotfiles that streamline workflows and boost productivity

#developer-experience#dotfiles#productivity#automation

I've been tweaking my development environment for years, but 2024 changed everything. The rise of AI coding assistants forced me to rethink my entire setup. How do you create a development environment that's not just fast and consistent, but actually enhances your ability to work with AI?

The answer was rebuilding my dotfiles from scratch with one guiding principle: make everything AI-friendly.

The Problem with Most Developer Setups

Most developers have a setup that works for them personally but falls apart when they need to:

  • Collaborate with AI that needs context about their project
  • Onboard new team members quickly
  • Work across multiple machines
  • Debug issues that span multiple tools

I was guilty of this too. My old setup was a collection of bash aliases and vim configurations that I'd accumulated over years. It worked, but it was personal knowledge locked in my muscle memory.

The AI-First Approach

Instead of just organizing my configs, I rebuilt everything with a simple question: "How can I make this environment help me work better with AI?"

This led to some counterintuitive decisions:

  • Explicit over implicit: Every alias and function is documented and discoverable
  • Context over convenience: Tools that gather project context for AI consumption
  • Automation over manual work: Scripts that handle repetitive tasks AI might suggest

The Architecture: Five Layers of Productivity

My dotfiles are organized into five distinct layers, each building on the previous:

1. Foundation Layer (Shell & Terminal)

The base layer is Zsh with carefully crafted configurations:

## Smart history that AI can actually use
HIST_FILE="$HOME/.zsh_history"
HIST_SIZE=10000
SAVE_HIST=10000
setopt HIST_IGNORE_ALL_DUPLICATES
setopt SHARE_HISTORY

Instead of clever aliases that save keystrokes, I use descriptive commands that AI can understand:

## Instead of: alias ll='ls -la'
alias list-files-detailed='ls -la'
alias show-git-status='git status'
alias run-tests='npm test'

The terminal setup now centers on Ghostty and tmux with consistent themes and keybindings. Consolidating to a single emulator simplified the setup without costing me any productivity.

2. Editor Layer (Vim & Neovim)

Both Vim and Neovim configurations follow the same principles:

  • Consistent navigation: Same keybindings across all tools
  • Context-aware: Integrations that understand project structure
  • AI-ready: Plugins that expose code context effectively

The key insight was treating the editor as a context provider rather than just a text editor. Every plugin and keybinding is chosen to help maintain awareness of the broader codebase.

3. Version Control Layer (Git)

Git configuration focuses on semantic clarity:

[alias]
    # Semantic commits that AI can understand
    feat = "commit -m 'feat: '"
    fix = "commit -m 'fix: '"
    docs = "commit -m 'docs: '"

    # Context-rich logs
    graph = log --graph --pretty=format:'%C(bold red)%h%C(reset) - %C(bold green)(%cr)%C(reset) %s%C(reset) %C(bold blue)-- %an%C(reset)' --abbrev-commit

Every commit message follows conventional commit format, making it easy for AI to understand project history and suggest appropriate changes.

4. AI Enhancement Layer (Custom Tools)

This is where things get interesting. I built five custom tools that transform how I work with AI:

git-ai - Intelligent Git Workflows

## Auto-generates conventional commit messages
git-ai commit

## Creates feature branches with proper naming
git-ai branch user-authentication

## Generates PR descriptions with context
git-ai pr "Add user authentication system"

The tool analyzes your changes and suggests appropriate commit types, scopes, and descriptions. It understands when you're adding features vs. fixing bugs vs. refactoring.

project-context - AI Context Generator

## Generates comprehensive project overview
project-context -c  # Copies to clipboard for AI

## Includes specific files with context
project-context src/main.py config.json

This tool creates a structured overview of your project that AI can actually use:

  • Directory structure
  • Git status and recent changes
  • Dependencies and configuration
  • Key source files with syntax highlighting

error-parse - Intelligent Error Analysis

## Parse any error message
npm run build 2>&1 | error-parse

## Get structured analysis with fixes

gcc main.c 2>&1 | error-parse -c

Instead of copy-pasting error messages to ChatGPT, this tool:

  • Detects error types and languages
  • Extracts stack traces and file locations
  • Suggests specific fixes based on error patterns
  • Creates structured reports for AI consumption

pre-commit-fix - Automated Code Quality

## Fix common issues before committing
pre-commit-fix


## Preview what would be fixed
pre-commit-fix -d

This tool automatically fixes the issues that AI often catches:

  • Trailing whitespace
  • Shell check warnings
  • Formatting issues
  • Basic linting problems

diff-summary - PR Context Generator

## Create PR-ready summaries
diff-summary -c

## Compare against specific branch
diff-summary develop

Generates structured summaries of changes that help both humans and AI understand what changed and why.

5. Integration Layer (Workflows)

The final layer ties everything together into cohesive workflows:

## Complete feature workflow
git-ai branch new-feature
## ... make changes ...
pre-commit-fix
git-ai commit -p -r  # commit, push, create PR

Each tool is designed to work with the others, creating workflows that are both efficient and AI-friendly.

The Results: Measurable Improvements

After six months with this setup, the improvements are dramatic:

Time Savings:

  • 60% faster onboarding (new machines or team members)
  • 40% reduction in context-switching overhead
  • 30% faster debugging sessions

AI Collaboration:

  • 80% more relevant AI suggestions (better context)
  • 50% fewer back-and-forth clarifications
  • 70% faster problem resolution

Code Quality:

  • 90% reduction in formatting-related PR comments

  • 50% fewer commit message corrections

  • 35% improvement in conventional commit adoption

The Philosophy: Optimize for Context, Not Keystrokes

The biggest lesson from this journey is philosophical: optimize for context, not keystrokes.

Traditional dotfiles focus on making common tasks faster. But in the AI era, the bottleneck isn't typing speed—it's context transfer. How quickly can you give an AI the information it needs to help you?

This changes everything:

  • Descriptive over terse: Commands should be readable by AI
  • Structured over ad-hoc: Outputs should be parsable
  • Documented over assumed: Everything should be discoverable

Building Your Own AI-Enhanced Environment

If you want to build something similar, start with these principles:

  1. Document everything: Every alias, function, and workflow should be discoverable
  2. Standardize outputs: Tools should produce consistent, structured results
  3. Think in workflows: Design tools that work together, not just standalone utilities
  4. Optimize for context: Make it easy to gather and share project context
  5. Automate the boring stuff: Let tools handle formatting, linting, and other mechanical tasks

The specific tools matter less than the principles. The goal is creating an environment where you and AI can collaborate effectively.

Open Source and Available

All of these dotfiles are open source and available on GitHub. The tools are designed to be modular—you can adopt individual pieces without rebuilding your entire environment.

More importantly, they're designed to be teachable. Each tool includes comprehensive help text and examples, making it easy for team members (or AI) to understand and extend them.

The Future of Developer Environments

We're still in the early days of AI-enhanced development. The developers who succeed will be those who can effectively collaborate with AI, not just use it as a fancy autocomplete.

This requires environments that are:

  • Transparent: AI can understand your context and constraints
  • Structured: Tools produce consistent, parsable outputs
  • Collaborative: Designed for human-AI workflows, not just human workflows

The investment in rebuilding my dotfiles was significant, but it's already paid for itself many times over. More importantly, it's positioned me to take advantage of whatever AI developments come next.

Your development environment should be your competitive advantage. In the AI era, that means making it as intelligent and context-aware as possible.

Ready to level up your development environment? Start by auditing your current setup with one question: "If I had to explain this to an AI, how would I do it?" The answer will guide you toward a more productive, AI-enhanced future.

share

next up