The machine, agent environments, remote access, and alerting behind a one-person operation.
Three build scripts sat at my repo root. The real problem wasn't those three — it was one v1 test file mixed into the directory holding the current pipeline. There was no cheap fix, so I moved things and deferred the judgment.
Porting a road-camera app to Android, I reread the API spec. The type parameter was not a filter — it selected a dataset, and the app only ever called one of them.
A real build across all 46 apps found 20 compile failures. The cause was not my code — it was a memberwise initializer the compiler synthesized inside an SDK.
68% of sessions had zero output tokens, so I concluded the app was not speaking first. The hypothesis was refuted by a sibling app that already had that feature.
I counted zero audio tokens across 271 sessions in three voice apps and went hunting for an audio bug. Halfway in, I found the number was a tautology, not an observation.
Defaulting actor isolation to the main actor synthesizes an isolated deinit only for classes that do not write one. The classes that wrote nothing are the dangerous ones — the exact opposite of intuition.
In the newer test framework, a -only-testing filter that matches nothing is not an error. It runs zero tests and reports success. The run meant to confirm RED finished green.
Gesture wiring can't be extracted into a pure function, so I measured pixel change instead. Three things silently make that measurement meaningless, and I walked into all three.
I inserted one guard line across 31 apps and ran a parse check. All 31 passed. Then I ran a typecheck and all 31 failed — I had planted the call to the guard without planting its definition.
I added a one-line loop to wait for a long job to finish. That loop never ends: pgrep -f matches the full command line, and the waiting shell's own command line contains the string it's searching for.
I made a git worktree to isolate the work and cut releases from it. The release manifest pinned the project path to the main checkout with an absolute path. The build succeeded. The upload succeeded.
I opened an existing deploy script before shipping a string fix. That script overwrites the live listing with the repo's listing files on every run. 47 fields I'd fixed via API the day before would have reverted silently, and the deploy would have exited successfully.
I rebuilt three rejected Android apps and verified them before upload. All three failed to read, and for a moment I suspected the signing. The cause was that the verify shell had no path to the key tool, so the command never ran at all.
Every app has its own deploy script and they're nearly identical. Run with --dry-run first, and if the output looks right, drop the flag and run again. That day I ran it with --dry-run and the version shipped to production anyway. That script had no argparse.
The simulator screenshot matched the code and only the physical device disagreed. Before suspecting the code, I should have looked at the install artifact.
An interactive tailscale ssh session exited instantly with zero bytes. The tailnet, the ACL, the host key, the version warning — all innocent. The real cause: CLI sessions nobody had touched in 20 days had consumed every PTY. And the thing holding each PTY wasn't claude — it was its parent shell.
I was one keystroke from running a static-site deploy script to fix a single sentence in a privacy policy. I pulled the 178 live files first and compared them: zero matched the repo, and live was about 50KB larger per page. Deploying would have erased that much from 170-odd pages.
Same company, same .p8 key, same team ID. One endpoint takes a Bearer token; the other takes a URL signature. I saw the 401 and spent the next hour fixing my credentials.
The stub was more forgiving than the real thing, the test input was cleaner than what the caller actually passes, and the self-verification check verified nothing. All three were green.
Every element was in the HTML and there wasn't a single error. But useEffect never ran once. The evidence wasn't in the browser at all — it was in the dev server log.
I renamed ten channels through the API. No errors, ten success lines in the log. Then I read the values back and not a single title had changed. Here are the five silent failures I hit in one day.
Moving a git repo out of iCloud Drive to local disk with `mv`, hundreds of files wouldn't finish for over 10 minutes. iCloud files may not actually be on disk, and `mv` triggers a synchronous per-file download when it touches them. Worse, modern macOS uses APFS dataless files, not `.icloud` sidecars, so `find -name '*.icloud'` finds none of them.
I could create and delete files but `open()` failed. `Operation not permitted`. Full Disk Access was already on, and the sandbox was irrelevant. The culprit wasn't TCC — it was an EndpointSecurity-based DLP agent, and the key to diagnosing it was the asymmetry: only files the current process just made were readable.
34 web apps, a handful of paper-trading bots, and a multilingual video pipeline — all run from a 2017 Intel laptop that just stays on. Here's the whole setup and why the old hardware helped.
Tailscale lets me watch local bot dashboards from my phone without exposing anything publicly. But tearing a bot down doesn't clear its Tailscale route — here's the gotcha that left dead ports looking alive.
The bots that make real decisions ping me on Telegram. The paper and test bots stay silent by design — a failed send there is expected, not a bug. Signal beats coverage.
The environment I run Claude Code and Codex in went through three stages. Each move solved the same problem: how do you run several agents at once and know which one needs you?