Skip to content

Software projects

Things I built that are in use today: the agent system that runs my AI coding agents, an on-device dictation app, and an AI assistant for a small coaching business.

about 63
merged pull requests a day in Autonomation, automated version updates includeda
over 1.5 million
words dictated with the dictation appb
about 15
hours a week saved for the coachc

a A daily average, Sep 23 to Oct 22, 2026. b As of Oct 2026, from the dictation app's own usage history, across both of my Macs. c As of Oct 2026: the coach's own estimate.

Autonomation

Agent infrastructure.

What it is. The name I use for the whole system that runs my AI coding agents: the agent fleet, its guards, the control plane, and the review gates. It is automation that stops itself when something is abnormal. Recorded failures drive new guards and regression checks, with enforcement limits documented.

Why I built it. On a factory line I designed around the failures I knew would come. The same habits carry over to AI coding agents: add a guard after a real failure, and never take a tool's word that it worked.

How it is built.

  • Agents: Claude Code, Cursor, Codex and open-source models.
  • Review: every pull request in the main repositories must pass an independent AI review gate.
  • Platform: the machines and services the agents run on, built with Proxmox, Ansible, Vault, and single sign-on.
  • Observability: Prometheus, Loki, and Grafana.
  • Model gateway: one cloud gateway that routes chat, vision, and speech-to-text requests across several model vendors and a local backend.

Results.

  • Throughput: about 63 merged pull requests a day, automated version updates included (over Sep 23 to Oct 22, 2026).
  • Agent activity: 4,768 agent runs (30 days to Oct 28, 2026).
  • Engineering base: 40,000+ automated tests across three repositories, 20,000+ of them in the main repository, and 73 architecture decision records.
  • Environment: 9 main machines and 96 private repositories.

Status. In daily use. Where each part stands is on the trust page. Read about Autonomation →

Dictation app

On-device dictation for macOS, with Windows planned

What it is. An on-device dictation app for macOS, with Windows planned. On the Mac it runs NVIDIA Parakeet speech models through the MLX framework.

Why I built it, and what it does. I built this because the dictation tools I tried were slow or handled local models poorly. A hotkey starts and stops recording, and the transcript returns to the field I was using. Recognition and optional cleanup run locally on my Mac. The app is built in Rust and Tauri and is in daily use.

Where the data stays. On my Mac, dictation runs entirely on the device: the audio and the text stay on the machine. Cloud options exist in the code but are off by default. As of October 2, 2026, my usage history showed only on-device transcription, and a review of the code that day found no analytics, telemetry, crash reporting or update checks. Its usage figures come from a database on the Mac itself.

How it is built. Rust and Tauri for the app, NVIDIA Parakeet speech models for recognition, and an optional on-device cleanup pass that strips filler words.

Results. Over 1.5 million words dictated (the dictation app's own usage history, across both of my Macs, as of Oct 2026). On my Mac, read from the app on Oct 23, 2026: 214 hours of dictation, and about 131 hours saved against a typing baseline of 60 words per minute. Speaking speed: about 240 words a minute while speaking (pauses over half a second removed), measured over 2,975 dictations.

Status. In daily use; Mac and Windows app-store releases planned.

Coaching assistant

AI assistant for a small coaching business

What it is. It syncs the coach's client data (metrics, check-ins, programs, and messages) into its own database to build context for each client. It drafts every message, check-in reply, and training program, and she reviews and edits each one before anything is sent. A LoRA adapter fine-tuned on her real replies matches her tone. It only reads from her coaching platform, except for one explicit send path she controls.

Why I built it. I wanted to give a small coaching practice back the time it spends on messages, check-in replies and training programs, without taking any decision away from the coach.

How it is built. Built with FastAPI, Next.js, and PostgreSQL in three containers, with live updates over a WebSocket.

Results. It saves her approximately 15 hours a week (the coach's own estimate, as of Oct 2026).

Status. In use by the coach.

More systems and services

More systems I have built, set up and run. Where I deployed and configured off-the-shelf software, the card says so.

Open the list for the household finance app, the agent control panel, the home automation with its custom C++ sensor component, and the hosted services.

Additional systems and integrations
  • Household finance app

    Built and operated

    I built this web app to track our household's money: about 14,000 lines of code, a FastAPI back end with about 70 endpoints over an 11-table Postgres database, and a Next.js front end with six screens. Each night it pulls in our bank and card transactions. Categorizing runs in three steps: my own rules first, then a language model held to a fixed answer format, then a splitter for multi-item orders; the model also fills in the details of online orders. Returns are matched to their refunds. I can load statements from files, edit categories and rules by hand, and see the totals on a dashboard. The database is dumped and backed up daily.

  • Home router control

    Built and operated

    I built a web app that manages my home router's traffic rules from one page and logs every change.

    Read more

    I built this web app to manage my home router's traffic rules from one page. For each device or website I choose the route its traffic takes, including which VPN exit it leaves through. The app writes the rules to the router, repairs the router-side settings that routed traffic depends on every time it starts, and logs every change. It also has a kill switch, DNS-based routing, a recurring speed test of the exits and metrics for my monitoring. About 4,100 lines of Python, 56 endpoints and 37 automated tests.

  • Home network and security

    Deployed and operated

    I run the security and monitoring layer of my home environment on open-source tools.

    Read more

    I run the security and monitoring layer of my home environment on open-source tools, and each tool reports its own health to my monitoring stack. My sites are joined over encrypted tunnels, and the network is split into separate segments.

  • Monitoring and alerting

    Deployed and operated

    I run Prometheus, Loki and Grafana for the machines and services in my environment, with Promtail shipping logs, Tempo and an OpenTelemetry collector for traces, and Alertmanager routing the alerts. Prometheus scrapes over 150 targets and evaluates over 500 rules; the alert rules live in code, 32 rule-test files prove they fire, and nearly all of them link to a runbook page that says what to do. A new service goes through a seven-lane plan that includes monitoring, so its scrape target, dashboard and alert are built with it.

  • One incident list for every alert

    Built and operated

    Alerts, coded service errors and security-scanner findings all land in one incident list, an append-only log that now holds more than 340,000 events. Repeats of the same problem fold into one incident, a problem that returns after it was resolved reopens the same incident, and an acknowledged incident reopens when its acknowledgement runs out. A triage worker finds the runbook for each incident and records the escalation. About 5,100 lines of code and 145 automated tests.

  • Agent control panel

    Built and operated

    I run my agents from this installable web app. I can start sessions, message agents and steer them from it. It has 24 screens: what's running, what needs my decision, which plan gates are waiting for me, the run ledger, open pull requests, alerts, the backlog queue, security findings, usage, and fleet and GPU status. More than 44,000 lines of code and tests, 77 endpoints and 594 automated tests.

  • Shared backlog for my machines and agents

    Built and operated

    This web service is the shared store behind my agent fleet. It keeps one backlog for all my machines and agents, so when an agent finds a bug outside its task it files it here, and it also holds the run ledger: every dispatched agent run is a row, more than 8,700 of them as of Oct 29, 2026, with the message threads between me and my agents beside them. My agent control panel reads its queue from the same service. More than 4,000 lines of code, 19 endpoints and 321 automated tests.

  • One sign-in check for my web apps

    Built and operated

    I built this small service to sit in front of my private web apps. Each app asks it who the person is and what they're allowed to open, so every new app gets the same check instead of writing its own. It says no when it cannot tell, reloads its access policy without a restart and refuses a broken policy file, and a new app joins with three lines of configuration. It is built on a shared library of my own, with 45 automated tests.

  • Home controls for my computers

    Built and operated

    I built this small service so my computers can read and switch things in the house through one controlled path.

  • Notification service

    Built and operated

    I built this small web service so every system and agent I run sends notifications through one call. It delivers push notifications to my phone (and can pin a message to one device), adds email for high-priority alerts, routes each calling app by its own settings, tracks each app's push quota and publishes metrics to my monitoring. Seven endpoints, about 1,300 lines of code and 60 automated tests.

  • Home automation and a nitro cold brew system

    Configured and extended

    I run our home automation on Home Assistant and built a nitro cold brew system the house controls.

    Read more

    I run our home automation on Home Assistant, with about 125 automations, 48 configuration packages, 10 Python modules and 8 dashboards of my own. I also designed and built a nitro cold brew system plumbed into the house, with a nitrogen valve the home automation controls and an oxygen sensor in the kitchen. When an existing component misread the oxygen sensor, I built my own in C++ for ESPHome, added a one-press fresh-air calibration, and track the sensor's health from its signal over months.

  • Room-level presence from Bluetooth and Wi-Fi signals

    Built on off-the-shelf tools

    I built room-level presence for the house from Bluetooth and Wi-Fi signals.

    Read more

    I built room-level presence for the house from Bluetooth and Wi-Fi signals. Bluetooth proxies I configure myself, and the house's own radios, hear our phones and watches, Wi-Fi signal strength adds a second source, and Home Assistant works out which rooms are occupied. The calibration tools and the classifier are my own code, about 1,700 lines: I walk through each room with a phone, they record a short run of signal samples, and the classifier learns each room's signal pattern, then picks the room every two seconds.

  • Home cameras with bear detection

    Deployed and operated

    I fine-tuned and trained a model that detects bears on our home cameras.

    Read more

    I fine-tuned and trained a model that detects bears on our home cameras. A bear detection triggers an alert in the home automation.

  • Grading tool for camera detections

    Built and operated

    I grade what the cameras detected in a web tool and export my verdicts as a training dataset.

    Read more

    I grade what the cameras detected in this web tool: bear, person, dog, animal, vehicle, nothing or junk. Another model proposes the boxes first, and my verdicts are exported in the standard COCO format as a training dataset for a detection model. I have graded more than 600 frames by hand so far.

  • One keyboard and mouse across my computers

    Built on off-the-shelf tools

    My own scripts coordinate one keyboard, mouse, speaker and microphone across my computers.

    Read more

    My macOS and Windows scripts coordinate one keyboard, mouse, trackpad, speaker and microphone across my computers, and switch the displays to suit whether I'm at the desk, docked or away. Off-the-shelf tools do the heavy lifting: a commercial tool for keyboard and mouse sharing, JackTrip for audio, Hammerspoon and BetterDisplay for the Mac's displays. The glue is my own: about 15,600 lines of PowerShell, Lua, Python and shell with test doubles of its own, built over 128 commits since August.

  • Self-hosted password manager

    Deployed and operated

    I host my password manager myself and deployed it from code.

    Read more

    I host my password manager myself and deployed it from code. It's backed up daily with an encrypted copy offsite, and its alerts each link to a runbook.

  • Nextcloud

    Deployed and operated

    I run our household file storage and sharing on Nextcloud, deployed from code.

    Read more

    I run my own file storage and sharing on Nextcloud for our household. I deployed and configured it from code, with its own database and cache, the app on local solid-state storage and the files on a separate storage server with its own snapshots. The database is dumped and backed up daily, shared group folders, a photos app and a Home Assistant integration are switched on, and a metrics exporter feeds the monitoring.

  • Immich

    Deployed and operated

    I host our family photo library on Immich, deployed from code.

    Read more

    I host our family photo library on Immich, the open-source photo server, instead of a cloud photo service. I deployed it from code as four containers, with its machine-learning service on a GPU. The database is dumped and backed up daily, the photos sit on a storage server with its own snapshots, and four alert rules (server down, database down, memory high, restart loop) each have a runbook.

Last reviewed Oct 28, 2026