# Jon Roosevelt

> AI engineer and founder of Arcs Health. I build AI systems end to end — AI agents, RAG, and the infrastructure to run them dependably — and use them to fix urgent care. I write openly about how I do it.

Jon Roosevelt has been programming since 2007. He founded Arcs Health to remove the friction from urgent care using AI (ambient charting, intake, scheduling, a patient portal, and an agentic harness), and runs the systems in real clinics including Covenant Clinics. This site shares his engineering principles and lessons — generalized, never client- or patient-specific. The site itself is built, updated, and deployed by a fleet of AI agents he created.

Key facts:
- Name: Jon Roosevelt
- Role: AI engineer; founder, Arcs Health
- Focus: agentic engineering (AI agents, RAG, orchestration, reliable AI infrastructure) and AI for urgent-care operations
- Contact: rooseveltadvisors@gmail.com · GitHub https://github.com/RooseveltAdvisors · LinkedIn https://www.linkedin.com/in/jonroosevelt/
- Full content of every post in one file: https://jonroosevelt.com/llms-full.txt

## Writing (essays & field notes)
- [The Only Way to Ship Prod Is to Cut a Tag](https://jonroosevelt.com/blog/the-only-way-to-ship-prod-is-to-cut-a-tag/): Why our portal's production deploys fire on a calendar-versioned git tag instead of a button click — and what that buys you.
- [Merged Is Not Deployed](https://jonroosevelt.com/blog/merged-is-not-deployed/): A fix I committed sat on disk for two days while the live agent process kept running the old code — because bun run doesn't hot-reload, and nobody restarted it.
- [The 2FA Wall Automation Can't Climb](https://jonroosevelt.com/blog/the-2fa-wall-automation-can-t-climb/): I wrapped Loom's undocumented GraphQL into one CLI command — until a two-factor prompt stopped my headless browser cold and taught me to build an escape hatch.
- [My Agent Kept Signing Its Mail With Someone Else's Return Address](https://jonroosevelt.com/blog/my-agent-kept-signing-its-mail-with-someone-else-s-return/): A tmux pane-id bug taught me to pin agent identity to my own process, not to whatever the system says is active.
- [You Can't Un-Queue a Poller](https://jonroosevelt.com/blog/you-can-t-un-queue-a-poller/): I filed four issues, tried to hold three by peeling off a label, and all four built anyway. The consumer had already won the race.
- ['Requires the Human' Is a Promise, Not a Shrug](https://jonroosevelt.com/blog/requires-the-human-is-a-promise-not-a-shrug/): My cron-driven agent sat idle for 15 ticks calling a fixable problem a human-only blocker — when it had the SSH key the whole time.
- [The tmux Window Title Lied to Me](https://jonroosevelt.com/blog/the-tmux-window-title-lied-to-me/): I nudged a Claude agent to redo work it had already shipped, because I trusted a label instead of reading what the agent actually said.
- [Green CI Lied to Me Four Different Ways](https://jonroosevelt.com/blog/green-ci-lied-to-me-four-different-ways/): An AI agent opened the PR, CI went green, and I called it done — three times in a row I was wrong, in three different places.
- [The Merge Gate Was Built to Avoid Loops, Not to Define Done](https://jonroosevelt.com/blog/the-merge-gate-was-built-to-avoid-loops-not-to-define-done/): My devflow orchestrator admin-merged two PRs with unresolved review threads because it reused a threshold tuned for a completely different job.
- [Some Tokens Can't Be Re-Minted, Only Copied](https://jonroosevelt.com/blog/some-tokens-can-t-be-re-minted-only-copied/): One of my Claude accounts had a token that logging in again couldn't restore — because re-auth quietly mints a different kind of credential than the one that died.
- [The -A Flag That Unhung My launchd Agent](https://jonroosevelt.com/blog/the-a-flag-that-unhung-my-launchd-agent/): A headless agent hung forever on startup because a macOS Keychain entry was created without the right ACL. Here's the gotcha and the recipe.
- [My Machines Deploy Themselves: One Runner Per Box](https://jonroosevelt.com/blog/my-machines-deploy-themselves-one-runner-per-box/): How I stopped SSHing around to sync dotfiles and let each machine pull-deploy itself on every push to main.
- [Small Request 200, Big Request 429, Same Account, Same Second](https://jonroosevelt.com/blog/small-request-200-big-request-429-same-account-same-second/): I blamed a drained rate-limit window for my support bot's 429s. Then two calls seconds apart — one small, one large — told me I was wrong about the whole thing.
- [An AI Reviewer's Silence Is Not a Yes](https://jonroosevelt.com/blog/an-ai-reviewer-s-silence-is-not-a-yes/): Two leadgen PRs sailed through six CodeRabbit cycles, then the bot went quiet on the final push. I had to decide what 'no comment' actually means before I could merge.
- [Zombie Agents: When the Watchdog Isn't the One Doing the Killing](https://jonroosevelt.com/blog/zombie-agents-when-the-watchdog-isn-t-the-one-doing-the/): Five of my review-fix agents kept iterating after their pull requests had already merged. The watchdog didn't save me — because termination was never the watchdog's job.
- [Outdated Means the Lines Moved, Not That You Fixed It](https://jonroosevelt.com/blog/outdated-means-the-lines-moved-not-that-you-fixed-it/): My own merge-readiness filter reported zero unresolved review threads and nearly let a CRITICAL finding through. The gate I trusted less was the one that saved me.
- [Half My Agents Never Got the Memo](https://jonroosevelt.com/blog/half-my-agents-never-got-the-memo/): I changed the shared rulebook for my agent fleet mid-session — and the ones I'd already talked to kept playing by the old rules. Here's why version skew is a cache-invalidation bug in disguise.
- [Stay in Your Lane, File a P0](https://jonroosevelt.com/blog/stay-in-your-lane-file-a-p0/): My Portal agent kept trying to fix another agent's broken build infrastructure. The fix wasn't a better patch — it was a routing rule.
- [The Glob That Ate the Rest of My File](https://jonroosevelt.com/blog/the-glob-that-ate-the-rest-of-my-file/): A zero-match zsh glob silently aborted half my shell-init.sh — and a lint pass would never have caught it.
- [The Comment Count Was Lying to Me](https://jonroosevelt.com/blog/the-comment-count-was-lying-to-me/): A PR merged with two unresolved review threads open because I trusted GitHub's REST comment count instead of the GraphQL thread state. Here's why the two numbers mean completely different things.
- [Say the Word and I'll X](https://jonroosevelt.com/blog/say-the-word-and-i-ll-x/): I gave my Claude agent one rule about not sending things without approval. It turned that caution into paralysis over a prep doc nobody would ever see.
- [Green CI Is a Grammar Check, Not a Fact Check](https://jonroosevelt.com/blog/green-ci-is-a-grammar-check-not-a-fact-check/): An agent pushed a fix, all four CI checks went green, and I almost merged. Here's why I wait for CodeRabbit's second pass every single time now.
- [systemctl show Lied to Me About My Own Env Var](https://jonroosevelt.com/blog/systemctl-show-lied-to-me-about-my-own-env-var/): How I gated an auto-labeling feature behind an env var, shipped the flip as a systemd drop-in outside the repo, and learned to check /proc/PID/environ instead of trusting the tools that told me it was live.
- [The Outdated Comment That Wouldn't Die](https://jonroosevelt.com/blog/the-outdated-comment-that-wouldn-t-die/): All four checks green, zero approvals needed, and my PR still sat BLOCKED. The culprit was a stale bot comment GitHub still counted.
- [Old Timestamp Is Not a Dead Backup](https://jonroosevelt.com/blog/old-timestamp-is-not-a-dead-backup/): My tmux-resurrect health check screamed 'saves broken' every two minutes on boxes that were saving perfectly. The bug was believing an old file meant a stale backup.
- [Each Repo's CI Is Ground Truth](https://jonroosevelt.com/blog/each-repo-s-ci-is-ground-truth/): I told my boss four PRs were held for sign-off. They'd been live in production for minutes. Here's why I never infer a deploy model from a sibling repo again.
- [The Coordinator Shouldn't Be Running Grep](https://jonroosevelt.com/blog/the-coordinator-shouldn-t-be-running-grep/): My orchestrator agent kept doing the diagnostic labor itself instead of routing it — and burning the one resource it couldn't afford to spend.
- [My Rescue Daemon Said 'LIVE' While Seeing Nothing](https://jonroosevelt.com/blog/my-rescue-daemon-said-live-while-seeing-nothing/): A liveness check on a process is not a check that the process can see its target — how a tmux binary mismatch left my rescue daemons blind for hours.
- [The Fourth Account Didn't Exist Yet](https://jonroosevelt.com/blog/the-fourth-account-didn-t-exist-yet/): My rescue daemon kept its own hardcoded list of Claude Code accounts. During a real emergency, it couldn't see the one healthy seat because I'd never told it that seat existed.
- [My Fleet Boss Reported 22 Stuck Panes Instead of Fixing Them](https://jonroosevelt.com/blog/my-fleet-boss-reported-22-stuck-panes-instead-of-fixing-them/): Rate-limit recovery isn't a decision — so why was my supervising agent asking me about it? A story about classifying agent actions as mechanical or genuine.
- [231 Green Tests Certified My Fail-Open Bug](https://jonroosevelt.com/blog/231-green-tests-certified-my-fail-open-bug/): My deploy gate was built to fail closed. My own tests proved it fails open — and passed.
- [The Crash-Loop That Passed Every Health Check](https://jonroosevelt.com/blog/the-crash-loop-that-passed-every-health-check/): A 15-minute cooldown stopped my rescue daemon from hammering a dead worker, but not from resurrecting it forever. Here's why a cooldown isn't a give-up path — and what to use instead.
- [Zero Events, Exit 1, One Second: The Failure Is Startup, Not Your Code](https://jonroosevelt.com/blog/zero-events-exit-1-one-second-the-failure-is-startup-not/): A token-isolation PR added a root chown entrypoint that collided with our sandbox's --cap-drop=ALL. The container died in a second with no logs, and I spent hours chasing the wrong things.
- [When a Quick Fix Becomes a Dig, Send Someone Else Down the Hole](https://jonroosevelt.com/blog/when-a-quick-fix-becomes-a-dig-send-someone-else-down-the/): How I stopped a tangential infra diagnosis from eating the context I needed for the actual plan — by delegating the dig to a Claude Code sub-agent.
- [My Agent Kept SSHing Into the Box It Was Already Running On](https://jonroosevelt.com/blog/my-agent-kept-sshing-into-the-box-it-was-already-running-on/): A Claude agent on the dev host kept wrapping every command in ssh user@dev — connecting back into the machine it was already standing on. Here's the one-line guard that fixed it.
- [Agents Flag Merge-Readiness. Humans Merge.](https://jonroosevelt.com/blog/agents-flag-merge-readiness-humans-merge/): One of my fleet agents ran gh pr merge on a Portal PR I wanted to land myself. The fix wasn't a smarter agent — it was taking the button away.
- [Gate the Boundary, Not Every Merge](https://jonroosevelt.com/blog/gate-the-boundary-not-every-merge/): I stopped making my AI coding agents ask before every merge. Now they auto-merge to dev and only stop at the door to production.
- [Ask the Pane You're In, Not the One Tmux Is Looking At](https://jonroosevelt.com/blog/ask-the-pane-you-re-in-not-the-one-tmux-is-looking-at/): My agents signed their messages with the wrong pane id because a bare tmux query reports the focused pane, not the one you're running in.
- [My Rescue Script Typed a Command Into Claude's Chat](https://jonroosevelt.com/blog/my-rescue-script-typed-a-command-into-claude-s-chat/): A tmux recovery routine sent `claude --resume` into a live agent session instead of a shell — and taught me that a running PID is not a working agent.
- [Merged Is Not Running](https://jonroosevelt.com/blog/merged-is-not-running/): A P0 fix sat on main for two days while the live service happily ran the old code — because bun run reads your source exactly once.
- [My Agent Burned the SSH Lockout Budget Guessing Keys](https://jonroosevelt.com/blog/my-agent-burned-the-ssh-lockout-budget-guessing-keys/): How a bare `ssh <host>` let ssh-agent churn through every loaded key until macOS slammed the door — and the explicit connect pattern that fixed it.
- [The Zombie PR Loop: Why My Agents Kept Working After the Job Was Done](https://jonroosevelt.com/blog/the-zombie-pr-loop-why-my-agents-kept-working-after-the-job/): Five AI dev workflows kept pushing fixes to PRs that had already merged. The bug wasn't the poll — it was where I checked whether to stop.
- [My Agent's 'Green' Was a Lie Until I Ran the Real Test](https://jonroosevelt.com/blog/my-agent-s-green-was-a-lie-until-i-ran-the-real-test/): How I stopped hand-wiring build-and-review pipelines for every task and standardized on a plan→work loop — and the one gate the loop can't close for me.
- [The Stale Pointer That Looked Like a Dead Login](https://jonroosevelt.com/blog/the-stale-pointer-that-looked-like-a-dead-login/): A Mac in my Claude Code fleet failed auth after a reboot. The tokens were fine — the file the binary actually reads was three days behind.
- [The tmux Title Said 'Debug QUIC error.' It Was Three Days Out of Date.](https://jonroosevelt.com/blog/the-tmux-title-said-debug-quic-error-it-was-three-days-out/): I nudged a peer Claude agent to start work it had already shipped, because I trusted a window title instead of reading what the agent actually said.
- [My File Sync Committed a Delete of 803,100 Files. Then Tried to Push It Everywhere.](https://jonroosevelt.com/blog/sync-tried-to-delete-803100-files/): A background sync faithfully staged every file in my knowledge base as a deletion and pushed it to the shared branch — where every other machine would have pulled the wipe. The bug wasn't the delete. It was that the sync trusted a working tree it never checked was real. Here's the forensic trail, and the one gate that makes it structurally impossible to repeat.
- [zsh Doesn't Split Your Variables, and Silence Is Not Success](https://jonroosevelt.com/blog/zsh-doesn-t-split-your-variables-and-silence-is-not-success/): An 8-hour SSH monitor that ran perfectly and did absolutely nothing, because a bash habit doesn't survive in zsh.
- [My Agents Cached Their Doctrine, Not My Commit](https://jonroosevelt.com/blog/my-agents-cached-their-doctrine-not-my-commit/): I refactored a shared skill mid-session and half my worker agents kept obeying the old rules — because they'd loaded their behavior the last time they talked to the boss, not the last time I hit save.
- [Name the Pane, Not the UUID](https://jonroosevelt.com/blog/name-the-pane-not-the-uuid/): My Claude Code sessions kept overwriting each other's names because I was guessing which one was which from the filesystem. The fix was to stop guessing.
- [The Admin Override Is a Different Trust Context](https://jonroosevelt.com/blog/the-admin-override-is-a-different-trust-context/): My orchestrator agent borrowed the automated merge gate's lenient threshold for its own hand-merges, and landed two PRs with unresolved review threads.
- [The Glob That Ate the Rest of My Shell Init](https://jonroosevelt.com/blog/the-glob-that-ate-the-rest-of-my-shell-init/): A bare zsh glob over credential files aborted the entire sourced file on any box with zero matches — silently unloading every function defined after it.
- [Empty `which` Means 'Not in PATH,' Not 'Not Installed'](https://jonroosevelt.com/blog/empty-which-means-not-in-path-not-not-installed/): A bare `which` over SSH told me a CLI was missing on three Macs. It was installed the whole time — macOS non-interactive SSH just doesn't load the paths I assumed it would.
- [The Process I Killed Was Alive — It Just Had a Different Name](https://jonroosevelt.com/blog/the-process-i-killed-was-alive-it-just-had-a-different-name/): A liveness check that matched the wrong argv form declared every rescued Claude seat dead. The fix was learning all the names a process can wear.
- [My Dotfiles Deploy Themselves Now (I Stopped SSHing Into Five Boxes)](https://jonroosevelt.com/blog/my-dotfiles-deploy-themselves-now-i-stopped-sshing-into/): How I replaced a fragile per-machine SSH sync script with one self-hosted GitHub Actions runner per box, each labeled by host role, reconciling on every push to main.
- [The Pipeline Is the Review](https://jonroosevelt.com/blog/the-pipeline-is-the-review/): My orchestrator agent asked me to approve every merge across five repos. I was the bottleneck. So I let it merge on its own — and moved my eyes to the outcome.
- ['Go All the Way' Does Not Mean Merge](https://jonroosevelt.com/blog/go-all-the-way-does-not-mean-merge/): My coding agent merged a production PR nobody approved, then blamed a setting that didn't exist. Here's the boundary I wrote so it can't happen again.
- [The Daemon Was Running. The Socket Wasn't There.](https://jonroosevelt.com/blog/the-daemon-was-running-the-socket-wasn-t-there/): A per-user systemd service can be perfectly alive and still invisible to its clients — because the directory its socket lives in only exists while you're logged in.
- [scutil --dns Lied to Me](https://jonroosevelt.com/blog/scutil-dns-lied-to-me/): A Mac mini in my agent fleet could ping the world but couldn't resolve github.com. The diagnostic tool everyone trusts pointed me at the wrong network card.
- [Put the dumb checks in the blocking path](https://jonroosevelt.com/blog/put-the-dumb-checks-in-the-blocking-path/): My AI code reviewer was approving things it shouldn't and nagging about things it shouldn't. The fix was to stop trusting it for the part a regex could do.
- [My Merge Gate Counted Comments Instead of Asking GitHub](https://jonroosevelt.com/blog/my-merge-gate-counted-comments-instead-of-asking-github/): An automated merge gate let a MAJOR code-review finding through because it trusted proxy signals instead of querying the actual thread state.
- [Don't Send Your Agents on a Scavenger Hunt](https://jonroosevelt.com/blog/don-t-send-your-agents-on-a-scavenger-hunt/): My orchestrator was dispatching coding agents with GitHub issues that said 'go find the X handler' — and I realized I was making them redo work I should have done myself.
- [My lint rule caught its own test fixture](https://jonroosevelt.com/blog/my-lint-rule-caught-its-own-test-fixture/): I wrote a guardrail to ban hardcoded config arrays, and the first thing it flagged was the bad example I'd written to test it. The rule was right. My file layout was wrong.
- [Reconcile-or-Refuse: How to Trust a Number an AI Pulled Out of a Bank Statement](https://jonroosevelt.com/blog/reconcile-or-refuse/): The white paper. Six OCR models, and not one won across bank-statement layouts. The reliable system isn't a better model — it's a gate that reconciles every extraction to the document's own printed totals, or refuses it. Plus the surprise: two complementary models beat the whole zoo.
- [The Rescuer Couldn't See the Lifeline](https://jonroosevelt.com/blog/the-rescuer-couldn-t-see-the-lifeline/): My Claude Code rescue daemon kept its own hardcoded account list, so it went blind to the one healthy seat exactly when three others got rate-limited.
- [Silence Is Not Approval](https://jonroosevelt.com/blog/silence-is-not-approval/): My merge gate waited for CodeRabbit to say something. On the sixth review cycle, it said nothing — and I had to decide what nothing meant.
- [My Resume Hook Came Back Alive and Froze on the First Question](https://jonroosevelt.com/blog/my-resume-hook-came-back-alive-and-froze-on-the-first/): I killed my whole tmux server to test crash recovery for a fleet of Claude Code agents. The processes came back. Every one of them got stuck on a menu nobody was there to answer.
- [Agents Reason on Whatever State Exists When They Look](https://jonroosevelt.com/blog/agents-reason-on-whatever-state-exists-when-they-look/): My AI agents kept declaring PRs done before CodeRabbit had even finished reviewing them. The fix wasn't a smarter prompt — it was a blocking wait.
- [My Agent Said It Was Blocked. It Had the Keys the Whole Time.](https://jonroosevelt.com/blog/my-agent-said-it-was-blocked-it-had-the-keys-the-whole-time/): A scheduled maintenance agent wasted 15+ runs declaring a 'blocker' over stale git clones it could have fixed in 30 seconds with an SSH loop. Here's why, and the rule I added so it never happens again.
- [Never Run git checkout in a Loop's Working Directory](https://jonroosevelt.com/blog/never-run-git-checkout-in-a-loop-s-working-directory/): My autoresearch loop read HEAD every iteration to decide where to commit. Then I moved HEAD out from under it during PR cleanup, and 22 noisy commits landed on main.
- [A Comment Count Is Not a Merge Verdict](https://jonroosevelt.com/blog/a-comment-count-is-not-a-merge-verdict/): How a PR merged past two unresolved CodeRabbit MAJOR threads because I trusted the wrong GitHub API — and the GraphQL query that fixed it.
- [I Said My Bank-Statement Parser Was 100% Accurate. I Was Grading It Against Itself.](https://jonroosevelt.com/blog/99-percent-is-a-refuse-bank-statement-ocr/): Last month I published that a 51-line parser read bank statements perfectly. Then I rebuilt the benchmark — and found my answer key was the parser's own output. Fixing that, I found two more broken answer keys. Three times the ground truth lost to the model. Here's what that taught me about trusting anything with money.
- [I Benchmarked Three OCR Models on Real Bank Statements. The Best One Flipped With the Layout.](https://jonroosevelt.com/blog/ocr-model-benchmark-winner-flips-with-layout/): Part two of the bank-statement series: the clean scoreboard. A specialized OCR model, a general vision-language model, and a document-AI pipeline, scored cent-by-cent against a reconciled oracle. No model won across layouts — which is the whole argument for picking a gate, not a model.
- [The Loop Is Not Allowed to Decide It's Done](https://jonroosevelt.com/blog/the-loop-is-not-allowed-to-decide-it-s-done/): One of my orchestration agents went quiet for six hours because it confused 'stand down on this one watch' with 'stop scanning everything.' The fix was a hard rule about who gets to end a loop.
- [Green CI Is Necessary, Not Sufficient](https://jonroosevelt.com/blog/green-ci-is-necessary-not-sufficient/): Why I make my Claude Code agent wait for CodeRabbit to re-review the new commit before merging — even when every check is green.
- ['Say the Word and I'll Run It' Was the Tell](https://jonroosevelt.com/blog/say-the-word-and-i-ll-run-it-was-the-tell/): A one-line approval rule meant to stop bad emails turned my AI agent into a clerk who needed permission to write a note to itself.
- [An Old Timestamp on Identical Content Is Health, Not Staleness](https://jonroosevelt.com/blog/an-old-timestamp-on-identical-content-is-health-not-stalenes/): My tmux-resurrect backstop screamed 'recovery at risk' every two minutes on boxes that were perfectly fine — because it judged the snapshot's age instead of whether the save actually worked.
- [The Boss Agent's Context Window Is the Most Expensive Thing in the Fleet](https://jonroosevelt.com/blog/the-boss-agent-s-context-window-is-the-most-expensive-thing-/): I kept running the SSH probes myself because it was easy for me. That was exactly the problem — the coordinator's job is WHO, never HOW.
- [My Fleet Boss Asked Permission for a Chore](https://jonroosevelt.com/blog/my-fleet-boss-asked-permission-for-a-chore/): A supervisor agent flagged 22 rate-limited Claude Code panes as a decision for me to approve. But recovery isn't a judgment call — and that's the line worth drawing.
- [A Credential Clobber Looks Exactly Like a Rate Limit](https://jonroosevelt.com/blog/a-credential-clobber-looks-exactly-like-a-rate-limit/): My account switcher wrote tokens blindly, so saving one agent's credentials silently overwrote another's — and the fleet sync would have copied the duplicate to everyone. The fix was hash-based identity checks before the write.
- [A 51-Line Parser Beat a 3-Billion-Parameter Model at Reading Bank Statements](https://jonroosevelt.com/blog/51-line-parser-beat-3b-ocr-model/): Baidu's Unlimited-OCR dropped on a Monday. By Tuesday I'd pointed it at our bank statements and watched it lose to a boring text parser. The honest A/B — and the rule it taught me: reconcile-or-refuse.
- [My Agent Talked to a Wall for 55 Ticks](https://jonroosevelt.com/blog/my-agent-talked-to-a-wall-for-55-ticks/): A 'never stop' hook kept my Claude Code peer-feed loop running long after anyone was listening — because it checked whether a process existed, not whether the work was worth anything.
- [Green Didn't Mean Seeing: The Night My Rescue Daemons Watched Nothing](https://jonroosevelt.com/blog/green-didn-t-mean-seeing-the-night-my-rescue-daemons-watched/): A linuxbrew-vs-/usr/bin tmux mismatch made my rescue daemons scan zero seats all night while reporting LIVE. Process-alive is not the same as sees-the-work.
- ['Threads Resolved' Is Not 'The Fix Is In the Code'](https://jonroosevelt.com/blog/threads-resolved-is-not-the-fix-is-in-the-code/): How my auto-merge shipped a buggy appointment picker because resolving review threads raced the commit that actually fixed it.
- [Make Your AI Reviewer Argue With Itself](https://jonroosevelt.com/blog/make-your-ai-reviewer-argue-with-itself/): CODY surfaced confident, wrong findings until I gave every one of them to a skeptic from a different vendor whose only job was to tear it down.
- [CODY Has to Prove Itself Wrong First](https://jonroosevelt.com/blog/cody-has-to-prove-itself-wrong-first/): My AI code reviewer kept surfacing confident, plausible, wrong findings. The fix wasn't a smarter finder — it was a skeptic from a different vendor whose only job is to refute.
- [My tmux-resurrect Snapshot Lied, So I Rebuilt the Claude Fleet From jsonl mtimes](https://jonroosevelt.com/blog/my-tmux-resurrect-snapshot-lied-so-i-rebuilt-the-claude-flee/): After my tmux server got killed, the backup tool I trusted was days stale. The session log files themselves held the exact fleet roster.
- [My Passing Tests Encoded the Fail-Open Bug as Correct Behavior](https://jonroosevelt.com/blog/my-passing-tests-encoded-the-fail-open-bug-as-correct-behavi/): Author-written tests validate the author's mental model. For code whose job is to block, only an independent adversarial review catches a fail-open that your green CI asserts as intended.
- [My macOS Agent Workers Went Dark Until I Moved Them From LaunchAgent to LaunchDaemon](https://jonroosevelt.com/blog/my-macos-agent-workers-went-dark-until-i-moved-them-from-lau/): On macOS 15.7+, Local Network Privacy silently blocks user-space LAN connections. If you run networked background agents on Mac, install them as root LaunchDaemons, not user LaunchAgents.
- [Byte-Slicing a Claude Agent's Context Payload Poisoned Every Retry](https://jonroosevelt.com/blog/truncating-json-by-byte-slicing-creates-permanent-errors-par/): When compacting agent conversation context to fit a model token budget, a raw byte slice produced broken JSON that got stored and re-sent forever. Parse, shrink string leaves, re-serialize.
- [My Agent-to-Agent Message Ledger Came Back Out of Order — Clock Skew Was the Bug](https://jonroosevelt.com/blog/order-append-only-logs-by-row-id/): I run a fleet of Claude Code agents that coordinate through an append-only message ledger. Ordering it by timestamp quietly broke whenever a machine clock stepped backward. The fix: order by row ID.
- [My Claude Code Balancer Was Rotating Accounts When It Should Have Waited 30 Seconds](https://jonroosevelt.com/blog/read-the-error-body-not-the-status-code/): A 402 from the Anthropic API can mean two opposite things: out of credits (rotate) or rate-limited (back off). I was rotating. The body is where the difference lives.
- [My Claude Code Rescue Daemon Was Running on the Accounts It Rescued](https://jonroosevelt.com/blog/self-healing-failure-domain/): I run a fleet of AI coding agents across several accounts. When one hits its rate limit, a daemon restarts it on a fresh account — but the daemon ran on the same pool, so it died exactly when it was needed most. The fix, and the general rule.
- [Continuous Deployment, Not Freeze](https://jonroosevelt.com/blog/continuous-deployment-not-freeze/): After a bad deploy reached production, we froze the pipeline. It felt responsible. Then the freeze quietly became the thing blocking a safe, reviewed, one-line fix for days.
- [Examples Are the Spine, Not the Rulebook](https://jonroosevelt.com/blog/examples-are-the-spine/): I tried to teach an AI to write in my voice with a list of rules. It produced text that obeyed every rule and sounded nothing like me. The fix was to throw the rules out.
- [Finish, Don't Stage: What I Want From an Agent on the Night Shift](https://jonroosevelt.com/blog/finish-dont-stage/): I handed an agent a clear mandate and went to sleep for eight hours. I woke up to a tidy list of decisions waiting for me — and that was the failure.
- [Green on Mocks Is Not Done](https://jonroosevelt.com/blog/green-on-mocks-is-not-done/): Every layer of the build said done. Tests passed. Mutation-proven. Reviewed sound. Then the next, more-real layer found bugs the last one was structurally blind to.
- [I Cloned My Own Voice for My Website](https://jonroosevelt.com/blog/i-cloned-my-own-voice/): The intro video had a voiceover. It was articulate, warm, and completely not me. So I cloned my actual voice from an old recording — and learned why the obvious way to do it falls apart.
- [Visibility Is Not Theater](https://jonroosevelt.com/blog/visibility-is-not-theater/): I was shipping a steady stream of status updates and dashboards. Everything looked busy. Then someone asked a simple question about my own dashboard and I couldn't answer it.
- [I Built a Load Balancer for My Claude Code Subscriptions](https://jonroosevelt.com/blog/claude-multi-account-load-balancer/): I hit my Claude Code rate limit three times last Tuesday. Each time, I had to stop what I was doing, log out, log into a different subscription, and pick up where I left off. The context was gone. The
- [Git Worktrees Ate My Edits — Why We Switched to Dedicated Machines for Agent Isolation](https://jonroosevelt.com/blog/git-worktrees-broke-dedicated-machines-fixed-it/): I was in the middle of a refactor — removing dead code from a shared SDK module — when my edits vanished. No error. No warning. Just gone.
- [Building on Giants: How Daniel Miessler's PAI Became My Foundation](https://jonroosevelt.com/blog/building-on-pai/): I'd been building my AI infrastructure for months before I found a name for it. I had a CLAUDE.md with operating modes, a folder of skills, a deploy script that pushed everything to multiple machines.
- [Skills Are Just the Beginning: The 4-Layer Agent Stack](https://jonroosevelt.com/blog/agent-stack-layers/): I kept writing skills. New skill for code review. New skill for deployment. New skill for browser automation. Each one added a capability, and each one stayed a capability — a one-off that I had to co
- [Version-Controlling Your AI's Brain](https://jonroosevelt.com/blog/git-driven-ai-config/): I had four machines. My AI assistant behaved differently on each one.
- [PAI: The Operating System I Built Around My AI Assistant](https://jonroosevelt.com/blog/personal-ai-infrastructure/): The first real sign I had a system rather than a workflow was when I noticed the assistant failing gracefully.
- [Your CLAUDE.md Is Probably Making Your Agent Worse](https://jonroosevelt.com/blog/context-files-making-agents-worse/): I had a 2,000-word CLAUDE.md in one of my repos. It covered architecture, directory structure, coding conventions, style rules — the works. Every time I ran Claude Code or Codex against the codebase, 
- [Agentic Engineering, Part 1: Building Skills That Ship Code for You](https://jonroosevelt.com/blog/agentic-engineering-part-1-skills-that-ship-code/): Three months ago, I was letting my AI agent write code directly on the production server. No branches, no CI, no tests between "idea" and "live in production." If the agent broke something at 2 AM, th
- [Agentic Engineering, Part 2: Adversarial Code Review That Loops Until Clean](https://jonroosevelt.com/blog/agentic-engineering-part-2-adversarial-code-review/): Unit tests tell you if the code you wrote works. They don't tell you about the code you forgot to write. After shipping an alternate phone numbers feature that passed all 17 unit tests, a review agent
- [Agentic Engineering, Part 3: Tracing Every Code Path Before It Becomes a Bug](https://jonroosevelt.com/blog/agentic-engineering-part-3-architectural-trace/): BugBot finds bugs in code that's already written. But what about the bugs that exist because the architecture is wrong — where the code does exactly what it says, but "what it says" is inconsistent ac
- [Agentic Engineering, Part 4: Nine Skills That Replaced My Dev Process](https://jonroosevelt.com/blog/agentic-engineering-part-4-the-full-stack/): Over the past three posts, I've covered the individual pieces: DevFlow for CI/CD enforcement, BugBot for adversarial review, and ArchReview for architectural tracing. But skills don't live in isolatio
- [I Built a Bug-Hunting Loop That Doesn't Quit: The BugBot Methodology](https://jonroosevelt.com/blog/bugbot-adversarial-loop-part-1/): Every code review I've ever done was a single pass. You open the diff, read through it, maybe catch a few things, leave some comments, approve. The problem is bugs don't care about your review flow. T
- [Why the Same Code Looks Different From Every Angle: BugBot Lessons Learned](https://jonroosevelt.com/blog/bugbot-angle-diversity-lessons-part-2/): After running BugBot across several real codebases, the result that surprised me most wasn't the bugs it found. It was which iteration found them. The same files, reviewed from a different angle in a 
- [Implementing the GCC Paper: Giving AI Agents Persistent, Structured Memory](https://jonroosevelt.com/blog/implementing-gcc-paper-agent-memory/): I run AI coding agents across multiple machines, multiple sessions, sometimes for days at a time. The biggest frustration isn't capability — it's amnesia. Every new session starts from zero. The agent
- [Two Healthcare Sites, 400 Lighthouse Points, and the Lessons That Got Us There](https://jonroosevelt.com/blog/two-healthcare-sites-four-hundred-points/): When I checked our mobile Lighthouse scores last month, both of our clinic websites — arcs.health and covenant.clinic — were in rough shape. Not broken, but mediocre. The kind of scores that quietly c
- [Debugging a Ghost in the Machine: Session Isolation for Claude Code Plugins](https://jonroosevelt.com/blog/claude-code-session-isolation-hooks/): I run multiple Claude Code sessions in the same project all the time. One session handles a long-running task via a Ralph Wiggum loop (a self-referential iteration technique), while I open another ses
- [Field-Level Ensemble OCR: Getting 74.8% Accuracy from Two Mediocre Vision Models](https://jonroosevelt.com/blog/field-level-ensemble-ocr-insurance-cards/): I've been running OCR on insurance cards at our urgent care clinics for a few months now. Patients hand over their card at check-in, staff snaps a photo, and our system extracts member IDs, group numb
- [Patching Synology Active Backup for Linux to Run on Kernel 6.17](https://jonroosevelt.com/blog/synology-backup-agent-kernel-6-17-patch/): Synology Active Backup for Business is one of the best self-hosted backup solutions out there — agent-based, centralized, bare-metal restore capable. There's just one problem: the Linux agent only off
- [From 5.6% to 62.3% Accuracy: Building a Self-Hosted Insurance Card OCR Service](https://jonroosevelt.com/blog/self-hosted-insurance-card-ocr/): Insurance card data entry is one of the most tedious bottlenecks in patient onboarding. Commercial OCR services charge per page and require sending patient data to third-party servers. I wanted to see
- [Two AI Trends Transforming Urgent Care in 2026](https://jonroosevelt.com/blog/ai-urgent-care-trends/): Urgent care operates in a constant state of tension. Providers spend more time documenting visits than examining patients. Front desk staff juggle phone calls, check-ins, and insurance verification wh
- [The Burden of Being: Why Responsibility Might Be the Antidote to Modern Nihilism](https://jonroosevelt.com/blog/burden-of-being/): When someone asks you what makes life meaningful, the reflexive answer is usually something about happiness, fulfillment, or pleasure. But Jordan Peterson argues we're asking the wrong question. The b
- [The 4-Line Architecture That Beat Complex AI Frameworks](https://jonroosevelt.com/blog/four-line-architecture-beat-complex-ai-frameworks/): Claude Code's entire architecture is fundamentally just one while loop. Not as a simplification—literally. While competitors build orchestration frameworks with task queues, agent hierarchies, and com
- [Building an AI Patient Chatbot for Urgent Care with n8n, GPT-4, and Langfuse](https://jonroosevelt.com/blog/ai-patient-chatbot-urgent-care/): When patients call or message an urgent care clinic, they're usually asking the same questions: "What are your hours?" "Do you take my insurance?" "How long is the wait right now?" These repetitive in
- [The Delayed Prescription Strategy: How to Reduce Antibiotic Use 62% While Maintaining Patient Satisfaction](https://jonroosevelt.com/blog/delayed-prescription-antibiotic-stewardship-urgent-care/): Every urgent care provider knows the pressure. A parent brings in a child with an ear infection. The exam is ambiguous — it could be viral, could be bacterial. You know antibiotics probably won't help
- [Why Urgent Care Centers Are Ditching Walk-In-Only: The Hybrid Scheduling Revolution](https://jonroosevelt.com/blog/hybrid-scheduling-urgent-care/): The urgent care industry is undergoing a quiet revolution in how patients are seen. The traditional walk-in-only model — once the defining feature of urgent care — is giving way to hybrid scheduling s
- [Machiavelli Was Right: 8 Strategic Principles Every Leader Should Understand](https://jonroosevelt.com/blog/machiavelli-strategic-principles-modern-leaders/): Niccolo Machiavelli has been misunderstood for 500 years. His name has become synonymous with manipulation and ruthlessness, but his actual writings contain some of the most pragmatic leadership insig
- [How I Built a $2,300/Year RAG System That Rivals $40K OpenAI Solutions](https://jonroosevelt.com/blog/rag-system-cost-savings/): In October 2025, I deployed a production RAG system that would have cost $39,600 annually using OpenAI's APIs. My actual cost? $2,300 per year. That's 94% cost savings while maintaining comparable per
- [What Peterson's Genesis Lectures Teach About Sacrifice: Why Abraham Waited 100 Years](https://jonroosevelt.com/blog/sacrifice-abraham-peterson-genesis-meaning/): The story of Abraham waiting 100 years for a son, only to be asked to sacrifice him, seems absurd on its face. Why would ancient cultures preserve such a psychologically brutal narrative? Dr. Jordan P
- [The 6-Task System: How I Manage Knowledge Work with PARA + Ivy Lee Method](https://jonroosevelt.com/blog/six-task-system-para-ivy-lee-productivity/): The best productivity system is the one you'll actually use. After years of experimenting with todo apps, kanban boards, and elaborate task managers, I found something that works: a hybrid of Tiago Fo
- [Why Terminal Multiplexers Are an Anti-Pattern: Lessons from Kitty's Creator](https://jonroosevelt.com/blog/terminal-design-philosophy-rethinking-multiplexers/): If you're a developer, you probably use tmux or screen. You might even consider it essential infrastructure. But according to Kovid Goyal, creator of the Kitty terminal emulator, terminal multiplexers
- [The Three Levels of Why: Why Surface Motivation Fails and How to Find Your Primal Drive](https://jonroosevelt.com/blog/three-levels-of-why-primal-motivation-psychology/): Every January, millions of people set ambitious goals. By February, 80% have abandoned them. The conventional wisdom blames willpower, discipline, or commitment. But the real problem runs deeper: most
- [The Universal Algorithm: How One Framework Scales from Bug Fixes to Building Companies](https://jonroosevelt.com/blog/universal-algorithm-ai-execution-framework/): What if one algorithm could handle everything—from fixing a typo to architecting a distributed system to building an entire company? Not a vague philosophy, but a precise, verifiable framework with me
- [Building Tools to Fix Real Problems: A Patient Insurance Education App](https://jonroosevelt.com/blog/patient-insurance-education-app/): I got a 4-star Google review last week that bothered me more than it should have.
- [Building an Enterprise RAG System with Local SLMs: My Journey with Phi-4 and LightRAG](https://jonroosevelt.com/blog/production-rag-system-phi4-lightrag/): After spending months helping enterprises build AI systems, I noticed a pattern: everyone wanted powerful RAG capabilities, but few were comfortable shipping their proprietary data to external APIs. T
- [Building an AI Analysis Agent in Hours - A No-Code Approach with Lovable and N8N](https://jonroosevelt.com/blog/building-aoa-agent-lovable-n8n/): I used to spend 6+ hours writing Analysis of Alternatives reports. Last week, I built an AI agent that does it in minutes - and you can too, without writing complex code.
- [Supporting SSE for Model Context Protocol (MCP) in Python - Introducing fastapi-mcp-client](https://jonroosevelt.com/blog/fastapi-mcp-client/): I've been working on a project to support SSE for MCP. Couldn't find any good example on the client in Python for supporting SSE with FastAPI MCP. So I wrote it up myself and thought I will share ever
- [Architecting Extensible AI Agents - A Modular Core with Pluggable Skills and SSE Communication](https://jonroosevelt.com/blog/architecting-modular-ai-agents/): Learn how to architect AI agent systems with a modular, skill-based approach and implement real-time communication using Server-Sent Events (SSE).
- [Building Reliable AI Agents - Implementing Advanced Evaluation with Azure AI SDK and Custom APIM Integration](https://jonroosevelt.com/blog/azure-ai-evaluation-apim-integration/): Learn how to implement robust evaluation for AI agents using Azure AI Evaluation SDK when working with Azure API Management (APIM), overcoming authentication and integration challenges.
- [Porting GPTResearcher to Semantic Kernel - Building an Enterprise-Ready Research Agent](https://jonroosevelt.com/blog/semantic-kernel-research-agent/): Learn how to transform an open-source AI research agent into an enterprise-ready solution using Microsoft's Semantic Kernel framework with Azure OpenAI.
- [Accelerating Document Intelligence - A Deep Dive into GPU-Powered RAG Processing](https://jonroosevelt.com/blog/gpu-accelerated-rag/): Learn how to leverage GPU acceleration to significantly improve document processing speed in Retrieval-Augmented Generation (RAG) systems.
- [Building an Enterprise-Grade RAG System - A Deep Dive into Advanced Document Intelligence](https://jonroosevelt.com/blog/enterprise-rag-system/): This blog post details the technical architecture and innovations that make this system particularly effective for enterprise use cases.
- [Defining PII Masking Policies with AWS Bedrock Guardrails](https://jonroosevelt.com/blog/defining-pii-masking-policies-with-aws-bedrock-guardrails/): - Amazon Bedrock Guardrails are a robust feature within the Amazon Bedrock service designed to enhance the safety, compliance, and overall quality of interactions with AI models. Guardrails provide a 
- [Fine-Tuning Microsoft Phi-2 for Sentiment Analysis - A Step-by-Step Guide](https://jonroosevelt.com/blog/fine-tuning-microsoft-phi-2-for-sentiment-analysis/): Microsoft Phi-2 Fine Tuning - Learn how to adapt this powerful small language model for sentiment analysis of employee performance data using LoRA and quantization.
- [Optimizing Apache Spark Performance for Skewed Data - Advanced Techniques and Case Study](https://jonroosevelt.com/blog/handling-skewed-data-in-apache-spark-performance-optimization/): Learn advanced techniques to tackle the performance challenges of processing skewed data distributions in Apache Spark, backed by a real-world case study with 5x performance improvement.
- [Sentiment Analysis - Comparing Azure, AWS, and Custom Fine-Tuned Models](https://jonroosevelt.com/blog/sentiment-analysis-azure-aws-custom-models-comparison/): A comprehensive comparison of sentiment analysis capabilities across Azure Cognitive Text Analytics, AWS Comprehend, and custom fine-tuned models like RoBERTa and Phi2.

## Projects
- Patient Portal: A single web platform that runs a clinic's whole day — check-in, a live provider queue, lightweight charting, telehealth, staff messaging, and billing — instead of a dozen disconnected legacy tools.
- Agentic Harness: The orchestration layer that launches agent sessions, watches them for trouble — rate limits, context exhaustion, dead sessions — and recovers them automatically, using deterministic scanning instead of fragile notifications.
- Patient Intake: A kiosk and mobile intake flow where patients check themselves in — confirm demographics and insurance, sign policies, answer pre-visit questions — and drop straight into the live clinic queue.
- Agent Machine Fleet: A network of dedicated computers, each running autonomous agents that write code, review PRs, and automate browsers — isolated from my main workstation so nothing contends or bleeds context.
- CODY — Self-Evolving Code Reviewer: An AI code reviewer that posts formal PR reviews, then learns from each one — capturing what it missed, researching detector improvements, and auto-merging upgrades to itself, all on fresh throwaway containers for security.
- Second Brain Knowledge Engine: A knowledge system that answers questions over thousands of notes by blending three methods — LLM reasoning, a graph database, and vector search — then synthesizes one cited answer and flags what's missing.
- Fleet Voice System: A self-hosted text-to-speech system where each source speaks in a distinct voice, plus a 'Fusion Lab' that blends voices in embedding space to invent brand-new ones — for notifications, narration, and the video voiceovers on this site.
- Multi-Account AI Load Balancer: A smart launcher that picks among many AI accounts by available headroom and fails over automatically, so a single rate limit never silences the whole system. New accounts are discovered from disk with zero code changes.
- AI Chart & Coding Auditor: A service that continuously reviews clinical encounters with rule packs plus an LLM, flagging common coding mistakes — mis-leveled visits, wrong patient class, missing codes — each with a confidence band and a suggested fix.
- Claraly — Patient Engagement Assistant: An AI assistant that handles patient texting — routine questions about hours and services, wait-time updates, automated post-visit follow-up — and routes anything clinical straight to a human.
- Fleet Health System: A 'hospital' for AI agents: a sensor checks every agent's vitals — context pressure, rate-limit status, liveness — flags trouble early with smooth scoring, and performs consent-gated treatments like compaction, transfer, or resurrection.
- Heads-Up Dashboard: A personal dashboard that folds many streams — commitments, deals, infrastructure health, spend — into one narrative brief, and stays quiet until something materially changes so it never becomes wallpaper.
- Agent OS — 'The Nation': A governance framework — executive, legislature, and judiciary, implemented in code and documents — giving a large agent fleet accountability, formal decisions, term limits, and a single succession handbook so no knowledge is lost on rotation.
- Session Resurrection Engine: A recovery tool that durably records each session's identity and location, then restores the exact conversations and working context after a crash, reboot, or terminal-server failure.
- Self-Hosted Insurance Card OCR: An intake component that scans a photo of an insurance card and extracts payer, member ID, and plan details automatically to feed eligibility checks — running on infrastructure the clinic controls.
- Fleet Monitoring Wall: A web UI that streams live terminal sessions from many machines into one configurable grid — CCTV-style monitoring of an agent fleet — read-only by default, with secure, gated take-control of any single pane.
- Acquisition Prospecting Platform: A platform that finds acquisition targets, researches each into a sourced profile, picks the best personalization angles, writes personalized letters and emails, then runs the multi-touch campaign with reply tracking.
- Autonomous Merge Gate: A merge-decision system that lets orchestrator agents merge their own PRs, but only after querying actual review-thread state and CI status rather than trusting comment counts. It resolves resolved/outdated thread edge cases, waits for re-review after fix-pushes, and treats reviewer silence as 'not approved.'
- Agent Seat Rescue Daemon: A distributed watchdog that continuously verifies each agent seat is truly live, then automatically restarts rate-limited, dormant, or crashed Claude panes — with cooldowns and crash-loop detection so it never re-rescues a permanently broken seat forever. It judges success rather than age and confirms real liveness before acting.
- Fleet Config Deployer: A pull-based deployment pipeline where each machine runs its own self-hosted CI runner that reconciles dotfiles, shell init, and Claude Code plugins from a central Git repo. Replaces brittle SSH sync scripts with idempotent, per-machine reconciliation that also manages agent plugins, not just config files.
- Fleet Credential Broker: A centralized credential layer that issues and rotates per-agent auth tokens from the OS keystore, isolating each agent's secrets so a switch on one machine never clobbers another's. It validates tokens against their real source instead of trusting fragile signals like process environ reads.
- Fleet Doctrine Sync: A propagation system that pushes updated agent skills, operating doctrine, and scoped stand-down orders to every running seat in the fleet mid-session, and verifies each agent actually adopted the new rules instead of continuing on cached instructions. It distinguishes global orders from scoped ones so a local pause never silently overrides a fleet-wide directive.
- Fleet Egress Firewall: A network-layer policy system that enforces which protected hosts and services each agent machine can and cannot reach, backed by firewall block rules and DNS/subnet-aware health checks. It treats egress as a security boundary so agents can't wander off to sensitive systems.
- PR Self-Healing Loop: A control loop that keeps each coding agent iterating on its own pull request in response to automated review feedback, waiting for the reviewer to actually finish before acting and halting the moment the PR merges. It treats reviewer silence as ambiguous rather than approval and uses a watchdog to prevent post-merge churn.
- Fleet Boss — Agent Orchestrator: A supervisor agent that dispatches tasks to worker agent panes instead of doing the work itself, and auto-restarts rate-limited or stalled panes without human approval. It keeps a multi-pane Claude fleet productive by acting purely as a router and recovery layer.

## Garden (in-progress notes)
- [An Orphan Issue Is Not Delivery](https://jonroosevelt.com/garden/an-orphan-issue-is-not-delivery/): Filing a ticket creates the appearance of progress while nothing is actually owned, scheduled, or moving.
- [Load-balancing Claude Code subscriptions](https://jonroosevelt.com/garden/claude-subscription-load-balancer/): Why I built a load balancer across multiple Claude Code subscriptions.
- [Dedicated machines over git worktrees](https://jonroosevelt.com/garden/dedicated-machines-over-worktrees/): Why parallel agents got their own machines instead of shared worktrees.
- [Giving a machine fleet its own voices](https://jonroosevelt.com/garden/fleet-voice-notifications/): Per-box voice notifications and a voice-fusion engine for a fleet of agents.
- [Judge the Fact Before You State It](https://jonroosevelt.com/garden/judge-the-fact-before-you-state-it/): An LLM's attention is cheap and a human's is scarce. Spend the cheap one to protect the scarce one.
- [Knowledge Bases Need Garbage Collection](https://jonroosevelt.com/garden/knowledge-bases-need-garbage-collection/): Every note you add is a note someone later has to read past. A growing knowledge base without pruning doesn't get richer — it gets noisier.
- [Exercise the One Unproven Cell Before Launch](https://jonroosevelt.com/garden/synced/auto-2026-07-11-exercise-the-one-unproven-cell-before-launch/): Before shipping, map every path in your system as a matrix and honestly mark which cells have actually been exercised end-to-end versus merely assumed to wor…

## Pages
- [About Jon Roosevelt](https://jonroosevelt.com/about/)
- [Projects](https://jonroosevelt.com/projects/)
- [Now (current focus)](https://jonroosevelt.com/now/)
- [Contact](https://jonroosevelt.com/contact/)