Notes on the things I actually run and build.
My dictation app's read-aloud felt slow, and the text grab took the same 2.3 seconds in every app on the machine. That flat, identical number was the tell: the app had made itself owner of the system clipboard and stopped answering, so everything else waited behind it. The bug, and the fix.
Read the post →
My most expensive AI model didn't type a single line last night, and everything still shipped. The orchestrator-and-worker split: the big model writes the spec and reviews the diffs, a cheaper model types the code and proves it works, and your plan's allowance suddenly lasts the week.
A watchdog script that auto-submits stuck messages, a terminal that suggests your next message, and an assistant that believed both. For most of a day my agent took orders from a version of me that did not exist. What saved it, and what I changed.
Everyone writes code with AI now, and most of it gets committed after a quick read because it runs. The two ways unreviewed AI code slips in, why the AI PR-review bots don't save you, and putting a real security check and code review at the commit gate.
Two hotkeys on Windows: one dictates into any app, the other reads any selected text aloud. Whisper, a 3B cleanup model that fixes "two, no, three apples", and Kokoro TTS, all running on the homelab box. No account, no subscription, and the audio never leaves the network.
Keyword search only works when you remember the words, and half the time I don't. So I built search by meaning over close to 20,000 notes and 127,000 emails: local embeddings on plain CPU, a nightly incremental reindex, and a retrieve-then-reason answer mode.
Letting an AI agent actually run commands on your own server is powerful and a little terrifying. The two layers I built so a lazy musing never turns into a delete: an instruction layer that reads intent and asks first, and a hard block list the model cannot talk its way past.
My assistant's loader was pushing 219KB of memory into every message, and the model was getting the first 2KB of it. Where the rest actually went, the index that was quietly truncating on top, and the fix that keeps an index in hand and pulls chapters on demand.
Every post here has a header image and they all share one look. The small system that keeps the set consistent: a fixed style block in every prompt, flat over photoreal, a palette locked word for word, and me picking the one that fits next to the rest.
I wanted comments without handing a third party my readers and their words. So the comments here run on Remark42, self-hosted: one small binary, anonymous commenting, no tracking, and a comment database kept where a redeploy can never wipe it.
Monitoring that messages you every run becomes wallpaper, and then you miss the one alert that mattered. My homelab watcher runs every half hour but only pings on a transition: one alert when something breaks, one all-clear when it recovers, and a silence I can actually trust.
Six months into the App Store's existence I shipped a bilingual U.S. citizenship test app that hit number one in Guatemala, and a privacy-first browser with password-protected profiles. Objective-C, AdMob, and the two business models of 2009, tested the hard way.
OpenClaw ships QMD, an embeddings-and-reranker vector memory, as the default. For a homelab it's overkill. Here's the lighter setup I run instead: a concept index plus a small CPU embedding model, no GPU.
Things break quietly at 2am and you find out at 9. So every day at 4am a plain, deterministic job checks every system on the box, safely restarts what has fallen over, and leaves me one message about the rest.
Building Claude skills to migrate a backlog of legacy .NET apps, the model kept drifting and inventing things once the reasoning got heavy. What fixed it: move the deterministic work out of the model, into Python scripts and SQL, and let it only orchestrate the parts that need real judgment.
Connecting Gmail to my home server took five minutes. Personal Outlook.com took an afternoon: basic auth is dead, so it's your own Azure app registration, the Graph API, a device-code login, and a refresh token you keep yourself.
For a few months I ran close to twenty AI agents on my homelab, a chief of staff, a CTO, an SRE and more. Then I scaled the whole thing back to a single Claude Code agent. The token meter, the reliability tax, and the overhead of managing the managers.
A Visual Basic app from 1998: folder tree on the left, rich text editor on the right, every note its own RTF file on disk. The file-per-note design Obsidian later made standard, running on Windows 95, and what keeping it in a drawer taught me.
Prompt rules and memory are suggestions, and a long run drifts back to the em dash no matter what the file says. So I moved that one rule out of memory and into a PreToolUse hook: a shell script that checks every Telegram reply and blocks the send if a banned character gets through.
I run Claude Code on my home server and reach it over Telegram, so my homelab has a chat window now. The standing jobs, the two watchers I lean on, and what I learned running too many agents at once.
The early versions leaned on Windows Terminal being installed, so install step one was the first place things broke. 2.11 ships its own terminal engine instead, and owning the terminal is what made the rest possible: scheduled output panels, shell conversion, a variables manager, and per-provider AI keys.
I gave my homelab dashboard a real hands-free voice over a hand-rolled WebSocket. Local Whisper and Kokoro, voice activity detection, an animated face, an iPhone pop-out, and the one thing that wore me down in the end.
One of my AI agents was an SRE, a site reliability engineer. Every morning it scanned the homelab, wrote up what looked off, and filed tickets, but never touched the controls. Why read-only triage with a human approving beats handing an agent the keys at 6:30am.
A chief of staff, a CTO, an SRE, a developer, a QA, even a voice agent, all passing tickets across kanban boards while I sat at the top. How it was wired, what's inside a card, and where it slowly tied itself in knots.
Git is the tool I use every day and the one I have re-Googled the most. So in TerminalNexus I made the commands I actually reach for a menu and a right-click: real Git underneath, plus AI commit messages written from the diff and a pre-commit scan that catches secrets before they land.
About 125,000 messages back to 1997, made searchable in under a second, locally, with notmuch. How I did it, and the Thunderbird mbox trap that almost handed me a confidently empty index.
My notes are the second brain I run this homelab on, so I treat them like code. The whole vault is a Git repo that commits and pushes itself every few hours: full history, one-command rollback, and a separate snapshot layer underneath.
A small Grafana stack for the home server, the one security decision I reversed when I pulled Tailscale off a public VM, and how I keep six months of history from vanishing if a disk dies.
My home ISP blocks port 80, which breaks the usual Let's Encrypt HTTP-01 challenge. The DNS-01 path I use instead: a wildcard cert, no inbound port, and renewals I never touch.
It began because I could not get to my own notes. From OneNote lock-in to Trilium, a too-slow Raspberry Pi, an old laptop turned Linux server, everything in Docker, and finally closing every open port with Tailscale.
It started in 2012 as a GUI to coax my coworkers off Subversion and onto Git. The framework slog, the serverless detour, the breakthrough that made it work with any CLI, and how it grew into TerminalNexus.
I put the license check for CommandGit, now TerminalNexus, on a serverless function at app startup. A 30-second cold start turned the launch into a spinner. Why scale-to-zero is scale-to-cold, and the boring box that fixed it.
Finish a change, then switch to the browser to update the Jira ticket and paste in what changed. Every commit. So I put it on one TerminalNexus button: capture the ticket and message, commit with the key, and comment on the issue with the changed files. The script included.
In January 2023, before the chat models, I wired GPT-3 into TerminalNexus: explain a command in plain language, turn a description into a command, and a usage quota underneath. What building against the completions API felt like that early.
By 2019 I had a few hundred saved commands and kept forgetting why I wrote each one. So I added notes: a line on every command and project, written in the moment, for the version of me who comes back months later with no idea.
Before TerminalNexus there was a C++ app that replicated data between any two ODBC databases, diffed table schemas across Oracle, SQL Server and Access, and browsed Oracle without DBA rights. Built from 2003 to 2013, one driver quirk at a time.
Windows 95 machines got slower the longer you owned them, and the culprits hid in win.ini and six registry keys. I wrote a free C++ utility that listed everything launching at startup and gave each entry a checkbox. PC World put it in the May 1998 print issue.
Before the freeware there was a wine price list. Visual Basic 4, an Access database over DAO, Crystal Reports for the printed list a distributor lives by, and a Backup button that recommended a floppy disk. My first real app, and the start of a database habit.
Started February 1993, and the proof is hard-coded in the source. A catalog and viewer for text files on Windows 3.1 that hung 255-character names on 8.3 filenames, two and a half years before Windows 95 made that normal. Borland C++, OWL, and tooltips built by hand.
More posts as I build. Check back soon.
TerminalNexus