25 years of software, startups, and scar tissue.

$ stat ./gitdiot
  Author       : Michael Paige
  Title        : CDO (formerly), IC (currently), GitDiot (always)
  Started      : 1999
  Production   : ~100 projects · ~250k words · 25 years
  Currently    : rebuilding the workflow with AI from the terminal up

The long road

I spent 25 years in software. Started as an individual contributor writing code nobody would review. Climbed to engineering manager, then VP, then C-suite. Along the way I managed hundreds of people, sold companies, sat in board meetings, and slowly stopped building things.

Then I climbed back down.

Not because the view from the top was bad. It was fine. Good, even. But somewhere around year twenty I realized I was spending all my time talking about technology and none of my time using it. I'd become the person who approved architecture decisions but couldn't tell you what was in the package.json.

GitDiot is what happened when I decided to fix that. The name is the joke: git is version control — the thing every developer lives inside. Diot is the honest part. Because when you haven't written production code in a decade and the entire landscape has shifted underneath you, that's what you are. An expert beginner. A senior junior. A GitDiot.

We aren't just developers anymore. We are digital archaeologists, digging through layers of legacy code to find the truth of why a system exists at all.

The puzzle metaphor

Every technology in this stack is a piece that has to fit with every other piece. The work isn't learning any one tool — it's learning how they connect. Apollo talks to Supabase. Supabase talks to n8n. n8n talks to HubSpot. Claude Code helps write the glue.

Most content about AI tools treats each one as an island. "Here's how to use Supabase." "Here's how to use n8n." But nobody builds with one tool. You build with ten, and the hard part is the seams between them. That's what I write about.

The stack

$ cat ./stack.txt
  claude-code     # AI co-pilot for everything
  supabase        # postgres + auth + realtime + pgvector
  voyage-ai       # embeddings (voyage-3) for semantic memory
  fragrag         # custom rag layer over the above
  n8n             # workflow automation
  hubspot         # crm and sales
  apollo          # prospect data
  hetzner-vps     # bare metal — $12 a month
  ubuntu          # server os of choice
  cloudflare      # edge, dns, tunnels
  caddy           # reverse proxy with auto-https
  node.js         # backend services
  python          # scripts and automation
  aem · eds       # enterprise cms (15 years deep)
  git             # the thing everything lives inside

Why "field notes"

Because that's what they are. I'm not writing from a position of authority about AI (I've been doing this for less than a year). I'm not writing hot takes for engagement. I'm writing down what happened, what I learned, and what I'd tell someone who was starting the same journey a week behind me.

If something didn't work, I say so. If I got confused by documentation, I say that too. The gap between my bio and this blog's title is the whole point. A CDO who calls himself a GitDiot. Someone who has managed hundreds of people and sold companies, writing honestly about fumbling through OAuth errors at midnight.

That tension — seniority plus humility plus genuine technical curiosity — is the only brand I have.

Two simultaneous truths

// Philosophy #01 — the machine precision
I believe in code that lives, not just code that executes.
We spend too much time chasing the latest framework and
not enough time understanding the fundamental physics of
data and user intent.

  ✓ Simplicity is the ultimate sophistication, but
    complexity is often unavoidable.
  ✓ Technical debt is a high-interest loan on your
    future sanity.

// Philosophy #02 — the human wisdom
Technology is a human endeavor. We write for machines,
but we build for people. Every bug is a misunderstanding
between two minds separated by time and a keyboard.

$ cd ~/blog   ·   $ git remote -v