Automation

Six of my repositories had gone public straight from their working trees, carrying internal names, addresses, paths and real personal data in test fixtures. Rewriting files does not purge history, so every repo was deleted and recreated from a sanitized single-commit snapshot, and the publishing pipeline was folded into the nightly pusher with a fail-closed gate that is deliberately allowed to tolerate two things.

A multi-day video conversion job hit two unrelated failures in one day, and both had the same shape: one broken precondition outside any file, turned by the script into thousands of fast, confident per-file failures. A circuit breaker, a pinned driver, and a watcher that looks at rates instead of names.

Porting a working file-sync pattern from one project to another would have replicated a 188 MB authenticated browser session and a secrets file across the whole machine mesh, because the sync tool does not read the ignore file that version control does. Three options, one structural fix, verified by hashes and an absence check.

What started as moving two small apps to the control-plane machine became the complete retirement of a third machine as an application host. Dependency mapping first, an explicit 'park that one' that evidence later overturned, a symlink instead of rewriting a hundred thousand paths, 51 GB reclaimed, and two live credentials caught before they replicated.

A sweep after the watchdog repair found the fleet's automation registry listed 13 timers on a machine running 16, two of the missing ones backups. It also nearly 'discovered' a hole that did not exist, because a grep over unit files cannot see configuration that arrives through drop-in directories.

The service whose only job is to tell me when a device stops checking in was dead. The previous handoff said it had died the day before. It had never worked once: its sandbox was built before its script ran, and it was the one unit in its batch that nobody wired to the failure notifier.

I had encrypted backups of my private records and had never once put one back. Proving it worked also revealed that the older archive contained nothing at all.

Two passes in a row had shipped the wrong artifact one layer apart: a service running a process older than the source, then a deployed bundle older than the feature commit. The fix was a guard validated by running it against the actual stale artifact, a release workflow with automatic rollback, and, the same day, an API that only three bounded classes of caller can reach.

Jobs were queuing behind a busy machine for no better reason than habit about which machine owned that kind of work, so I separated who runs a job from where the job lands.

A standing read-only collector that checks contract parity, machine-to-machine reachability, required services and timers, and required paths across the fleet. Three design choices carry it: it keeps last-known-good evidence, it separates drift from probe failure, and it never repairs anything.

My notes could answer what I decided but not what I actually did, so I built a second searchable layer over the working history itself, and a rule for when it is allowed to be used.

I stopped picking which AI model runs each job by hand and built a router that scores the options on what each one has left, reserves the winner, and writes down why it chose.

Hashing every size-collision candidate on my NAS found fifty-two thousand duplicate groups and about 254 GB reclaimable. The interesting part was everything that nearly made the number wrong.

I assumed every machine could reach every other. Checking every direction properly found a quarter of the paths broken, and one repair job reported success while having quietly undone itself.

My entire knowledge base had no undo, and adding one turned out to be a real distributed-systems puzzle because the same files live on four machines at once.

I write a lot of scattered notes across a lot of projects, and instead of ever organizing them by hand, I built a pipeline that rebuilds and reorganizes the whole thing every night while I sleep.

A lot of the small jobs I was paying a hosted model to do did not need a frontier model at all, so I started running open-weight models on my own GPU box and let the routine work run for free.

I stopped doing my machines' work at the keyboard and built a way to hand a task to whichever machine should run it, let it run on its own, and pick up the result later.

Turned the fleet into a full mesh where every machine can reach every other one directly, passwordless, without hand-managed keys, laying the groundwork for running work anywhere in the fleet.