My Tooling: A Workflow Story

I recently asked an AI agent to dig through my shell history, dotfiles and installed packages and tell me what my setup actually looks like. The numbers were more honest than any "my dev setup" post I could have written from memory. This is the story they tell.

A day in my terminal#

My machine runs Debian 13 with the i3 window manager. There is no desktop environment to speak of: Mod4+Return opens Alacritty, Mod4+d opens rofi, Print opens flameshot, and a keyboard toggle (Alt+Shift) flips between us and tr layouts.

Inside the terminal, everything is vi-flavoured:

• bash with set -o vi
• vim as $EDITOR, with jj mapped to Escape, arrow keys disabled on purpose, and autosave whenever I leave insert mode
• tmux with mouse on, a 10 ms escape time, splits that open in the current directory, and tmux-resurrect + tmux-continuum so a reboot doesn't cost me my sessions

My history file holds around 19,000 lines (HISTSIZE=100000, duplicates erased). The most-used commands tell the real story:

cd      1821
git     1222
vim     1036
make     919
gc       769   (git commit alias)
ga       560   (git add alias)
nix      358
docker   329

I spend my life moving between directories, editing files and committing. Everything else is plumbing.

Rule one: every project speaks `make`#

Of the 160 projects in my `/www`, 61 have a Makefile. The pattern is the same everywhere:

make dev        # start the thing
make test
make deploy
make shell      # php-shell, node-shell, ...

make dev appears 100+ times in my history and make deploy more than 120. I don't need to remember whether a project is Node, PHP or Haskell, or which Node version it needs. The Makefile sets up its own environment, so I never type nvm use before make. Switching projects costs me no mental context.

Reproducible environments: Nix, direnv, and nvm as the compromise#

Where I can, I use Nix flakes (nix develop, nix build, nix shell) together with direnv, so entering a directory loads its toolchain. Eleven of my projects have a flake.nix, and Haskell work goes through nix develop instead of a global GHC (cabal builds inside the shell).

I'll be honest about the compromise: Node still lives in nvm, with seven versions installed, because JavaScript tooling and Nix remain an awkward pair. Rust (cargo), Go, bun, pnpm and ghcup sit alongside.

Git muscle memory#

Most of my git is aliases, and the commit one is deliberate (-s signs off every commit):

alias ga="git add"
alias gc="git commit -s -m "
alias gs="git status -s -b"
alias gd="git diff"
alias gp="gh pr create -a @me -B main "

# Push the active branch to origin
gpo() {
    local activeBranch
    activeBranch=$(git branch --show-current)
    if [ -n "$activeBranch" ]; then
        git push origin "$activeBranch" "$@"
    else
        echo "Error: Not on a valid branch."
        return 1
    fi
}

gpo alone shows up over 300 times in my history, and gp hands off to the GitHub CLI. I also keep Nostr twins (gpn, gupn) that push and pull the current branch to a nostr remote, using ngit and its git-remote-nostr helper, so my code is not tied to one forge. pull.rebase = true keeps history linear.

Shipping on Cloudflare#

Roughly two dozen of my projects are Cloudflare Workers or Pages, and npx wrangler deploy is the single most repeated npx command in my history. A typical new service with Wrangler goes:

npx wrangler d1 create <name>
npx wrangler d1 migrations apply <name> --remote
npx wrangler kv namespace create KV
npx wrangler deploy
npx wrangler tail

D1, KV, R2 and Queues cover nearly every backend need I have, which is why so many tiny projects exist. I use Cloudflare WARP for networking and Nostr tooling (nak, a Blossom server, hugo2nostr) for the open-protocol side of things.

AI agents, with a rulebook#

I use several agent tools: Claude Code, Codex, Gemini CLI, Cursor, Copilot, Cline and opencode. Instead of configuring each one, I keep a single rulebook in ~/AGENTS.md (the AGENTS.md convention) that points to per-language files in ~/.agents/languages.d/ (Haskell, PHP, Node, Python) and devops.d/ (Cloudflare). The main rules:

• Plan first, wait for approval, then implement step by step
• If a step fails, stop and explain; no silent workarounds
• Always run tooling through the Makefile
• No any, no empty catch, no hardcoded secrets, no TODOs

Reusable skills come in via npx skills add. For local work I run Ollama (gpt-oss:20b, qwen2.5, gemma3, llama3.2, codellama, llava for vision) plus LM Studio, backed by CUDA 12.6.

Small utilities worth stealing#

alias dc="docker compose"
alias x="xclip -sel clip"
alias p="openssl rand -hex 6"
alias youtube="yt-dlp --extract-audio --audio-format mp3 ..."

# Find and replace recursively
frf() { find "$1" -type f -exec sed -i "s+${2}+${3}+g" {} + ; }

Those lean on Docker Compose, xclip and yt-dlp. I also keep pass for secrets, BorgBackup and rsync for backups, Obsidian for notes, OBS and DaVinci Resolve for video.

What I'd change#

The history is honest about my habits too:

• Seven Node versions is a smell. Most of them exist for projects I've forgotten.
• 160 projects, many abandoned. A quarterly cleanup would help.
• I still use Nix only where it's easy; the rest depends on nvm and global installs.
• Several of my aliases (gc, ga, gs) are in HISTIGNORE, so my real git usage is higher than the counts show.

The takeaway#

My setup isn't clever. It is a small set of habits repeated a thousand times: one interface (make), one reproducibility story (Nix + direnv), one set of rules for agents, and short aliases for everything I type daily. If you take one thing from this post, let it be the Makefile rule.