I use AI-augmented development to ship production software that makes money. I architect the system and direct AI coding agents to write the code, and I’m a dozen production systems deep. Underneath it is a seventeen-year through-line: read the hardest ruleset in the room faster than anyone else, and turn it into a shipped system. Equal parts builder and the person the customer trusts.

The translator

Across every role I’ve held, it’s been the same faculty doing the work: read the hardest, densest framework in the room — federal funding law, a third-party API contract, a customer’s tangled requirements — understand it faster than anyone else, and turn it into money or a shipped system. AI-augmented development is the newest instance of the oldest skill.

That looked like building a grants department from nothing at an institution under real federal oversight, and rewriting its fiscal policy to the federal standard. At a forty-five-year community and economic-development consulting firm it looked like being the desk the entire staff — owner included — routed through when new federal relief legislation landed and nobody could tell what it actually meant. Public entities leaned on the same reading. It was worth hundreds of thousands in funding and revenue, and it was the same act as reading a payments API’s idempotency semantics closely enough to find where the guarantee quietly expires.

Agents that are safe to point at production

The thing most teams can’t get past is real model capability without the ability to cause real harm. My consulting firm’s entire front door is a conversation, not a form: one agent loop wearing four professional personas by entry context, each a versioned playbook, all sharing one hardened tool layer. It queries genuine calendar availability, books, sends the invite, takes payment on one surface, and lets a visitor come back later and cancel or reschedule through the same conversation. It manages the calendar. It doesn’t just write to it.

The hard part is safety, not capability. The cancel-and-reschedule path is the cleanest example: the naive version lets anyone cancel anyone’s booking by naming it, so I closed it by moving authorization out of the model’s reach entirely — the tools take no attacker-aimable arguments at all, and the server verifies an HMAC possession token and is the sole writer of identity. Paid intake is gated on a webhook-verified payment record, so the booking tool stays inert until the money is confirmed server-side, never on the model’s say-so. Card and SSN redaction runs at every persistence sink, Luhn-validated and longest-window-first, because a paid flow can prime someone to paste one.

On a recruiting and NIL platform, the intake agent goes further: it never sees the database. Tool schemas describe semantic fields and the server decides which table and column each lands in. An earlier version put the schema in the prompt and that was the source of roughly half its bugs. When the model over-applied a unit conversion it had been taught and turned a 9.8-foot broad jump into 117.6 inches, the fix wasn’t a better prompt — it was a type-and-range gate upstream of the table split that rejects a non-integer bound for an integer column by type, regardless of range, and quarantines the raw answer instead of corrupting the row. The point of that agent isn’t novelty. A nervous fifteen-year-old will run a chat window from their phone and drift in and out of it; they will abandon a thirty-field form. The conversation is the completion-rate strategy and clean structured data falls out as the byproduct.

Money that can’t double-charge

I’ve built and hardened a live billing engine processing customer payments across four Stripe paths — full payment, deposit-plus-installments on Subscription Schedules, arrears, and refunds — driven by webhooks that arrive out of order and get redelivered. The work is correctness under concurrency, not feature volume.

The sharpest bug in it is one nobody finds by reading code. Stripe retains idempotency keys for about twenty-four hours; a checkout link lives seven days. So the one-schedule-per-plan guarantee a deterministic key appears to give silently evaporates on day two, and a customer resuming their own link on day three mints a second real billing schedule. The defense is layered: the deterministic key for concurrency inside the window, plus an adopt-before-create reconcile that asks Stripe what already exists on every attempt. When a live billing incident hit, I diagnosed it against the Stripe event log rather than our internal theory — whichrefuted that theory and found an orphaned draft invoice colliding with Stripe’s own auto-advance timer. Customer made whole with an apply-forward credit, then the bug class closed structurally so the healing path couldn’t recreate it with money attached.

Alerting on that system can’t silently rot either. Every money-path alert marker calls one registry that throws on an unknown name, with a bidirectional proof that the registry and the emitted set match — so an emitted-but-unregistered alert is structurally impossible rather than merely unlikely. Severity splits paged from log-only, because a noisy page channel is the same as no page channel.

What fifty-two reviews taught me about reviews

Stated precisely, because the uncharitable version is false: the reviewworked on what it was aimed at, and zero money-path defects escaped to that walk. The failure was that review was aimed at bytes, on a dark zero-traffic system, for thirty-six sessions, while nobody walked the path once. And the worst of the three was structurally invisible to byte review — it only breaks when the buyer is already on the site, and every test arrived through a payment redirect into a fresh page load, where it works fine. That bug lived in the gap between how a reviewer arrives and how a customer arrives, which is not a gap you can read your way across.

What came out of it is the posture I run every build on now. Reality outranks review. If a thing can be walked, clicked or run, do that first — live behavior defines the fix list. Separate what protects money, data or a person from what protects against a hypothetical, build the first now, and let reality vote on the second. And say "we’re re-gating this" out loud the moment a session’s work becomes fixing what the last session’s fix caused.

Platform and cost discipline for LLM operations

Running large, long-lived AI-assisted projects under hard context limits produced a platform that treats session context like memory on an embedded target— finite, budgeted, spent deliberately. Five cooperating subsystems: an agentically described, content-addressed manifest, an MCP server that serves it, a self-healing reconciliation daemon, a document router that learns from its own corrections, and a live operational dashboard. Every build session I run boots through it, orients off its manifest, and verifies its claims with its own tools. The load is the proof — it governs the very sessions that build it.

The idea underneath is a cost inversion. Expensive comprehension — reading and understanding every file — is paid once, at write time, by local machinery: a daemon hashes genuine content changes (content-hash, never modification time, because mtime lies) and summons a one-shot, non-resident agent to write a single pinned description line, then dismisses it. At read time the model pays a sweep of one-liners at a handful of tokens each. A recurring cost in the scarcest resource, converted into a one-time cost in the cheapest. Runaway is structurally impossible — per-wake and per-hour caps mean a pathological loop physically cannot exhaust the budget, and there’s no metered API key in the system to leak.

And it’s instrumented to catch itself lying. Push-freshness is a promise; the read-time hash-verify is the proof. Every read re-hashes the served files against the index before serving, so a watcher that died on a reboot is caught the next time anyone looks, with a header naming exactly what drifted — never discovered days later as silent corruption. The index prunes in both directions rather than only appending; the first live sweep cleared 122 phantom entries across five groups in about a second. Every failure logs a distinct cause — timeout, launch failure, empty output, unparseable output — because an earlier build collapsed six failure modes into one string and two files sat stuck for a week with the evidence discarded at the moment of failure. The health surface measures correctness, not activity: a "last written twenty-seven minutes ago" column is liveness wearing health’s clothes.

Research that inverted its own assumption

The long-running R&D program is a recall architecture that treats query non-determinism and multiple valid interpretations as designed behaviorrather than a defect. Its goal was fixed from the start and its spec deliberately left open — the load-bearing parts were earned through testing rather than planned in advance. A divergent probe swarm reads a sealed verbatim floor through multiple state-colored instruments, and the synthesis layer refuses to converge. Twenty probes fired at a live query walked 109 spine nodes, 85 of them distinct, with 25 of 26 overlapping pairs crossing conversations — divergent routes arriving at a small shared core from independent doors, which is precisely why the convergence means anything.

The result I’d actually want to be asked about overturned my own assumption. I believed a single reader holding an entire pool was the gold standard and that fanning work across many small readers was a budget compromise. Read one hard thread both ways: the single-pass reader over 455 nodes passed every quality criterion I had, and was structurally blind to material at rank 57 in its own pool that a sixteen-way fan-out caught immediately. The mechanism is attention budget per node — a reader holding 455 skims, a reader holding 28 reads. Cost stopped being the scaling constraint and attention became it.

Delivery, deliverability, and other people’s walls

Sending email is easy. Sending it at volume from individual consumer mailboxes without tripping rate limits, landing in spam, or dying silently on a revoked token is not, and nearly every feature in that engine exists to survive a failure mode that only appears once real mail hits real inboxes: rolling per-account caps with automatic cooldown and resume, token-revocation detection with zero retries, a bounce-spike circuit breaker, per-recipient timezone windows, and fifteen parallel AI-generated copy variants for anti-fingerprinting. Only two states in it need a human to restart anything. Everything else resolves itself.

Bot-filtering runs at the data-integrity layer and rolls back engagement already credited once a cluster crosses a threshold — same-mailserver opens landing within five seconds of each other, multiple links on one message clicked within three. Corporate scanners auto-open and auto-click everything for security, and without that rollback every number downstream is garbage. Those thresholds are a position, not a fix. It’s an arms race against infrastructure that isn’t even hostile — every privacy or security improvement a mail provider ships routes around whatever heuristic currently works, on their schedule. A major platform now opening every message on the recipient’s behalf before they’ve seen it is the standing example: it didn’t break a rule, it made "open rate" mean something different overnight.

The constrained builds are where the forward-deployed muscle actually lives. I’ve kept two live systems consistent when one couldn’t be replaced — a public CMS that was the system of record, mirrored into Postgres with a real-time bidirectional bridge and nightly reconciliation, so serious operational tooling could exist alongside it without either side drifting. That platform ran a firm end to end and processed$100K+ in about six weeks live. And I’ve shipped a role-scoped document-management system for one of the largest townships in New Jersey entirely inside a locked-down low-code platform — no real database, no server I controlled, and embeds running in a separate origin that couldn’t call the backend at all. What came out is a strict three-layer message-passing architecture, because that’s what a distributed-systems seam looks like when the network is a browser boundary between two origins you don’t own.

The debugging there is the part worth telling. Two public pages hung on "Loading…" for a week with no error anywhere. Five theories got built and knocked down — slug mismatch, backend latency, a phantom collection, a stale binding, cache — before the real cause landed: a single silently reassigned element ID, because an embed had been deleted and re-added. What settled it was one quiet fact visible early in the network tab, that only one data query fired on load and it wasn’t the one the page needed. Follow the quiet fact, not the loud one. Separately, a five-hour regression from shipping three files at once produced a rule I’ve kept: revert to last-known-good to confirm the regression is in the new code, then deploy one file at a time with a verify step after each.

Judgment, before there’s any code to write

Some of the work has no software in it. I architected a parent-plus-two-subsidiary nonprofit structure satisfying three unforgiving regulatory regimes at once, with a documented funding firewall keeping restricted dollars provably separate under quarterly audit — separation of concerns and verifiable boundaries expressed in contracts instead of schemas. The moment worth telling is that requirements discovery caught the plan-breaker: incorporating in the client’s home state would have failed the target funder’s eligibility statute on its face, because the statute requires entities governed under its own state’s law. That’s the equivalent of reading the actual API contract and finding the naive integration can’t authenticate. Found before anyone built against it, with three resolution paths and a modeled fallback.

Public office, and the room

I served an elected term on my township committee, and it is the clearest evidence I have that the translator faculty isn’t a software trick. The budget surplus and the solar redevelopment came out of the same act as everything above — read the ruleset nobody else had the patience for, then build the thing it permits. I brought my township’s own fiber-loop and cell-booster feasibility request to the Lieutenant Governor and the State Senate President directly, and won the discretionary funding; I was voted out before implementation, which is its own lesson. Later, on the consulting side, I briefed the same offices on behalf of municipal clients and was project director on a multi-county fiber infrastructure award in the tens of millions.

There’s also a decade and a half of live performance behind all of it — a house musician’s chair at a nationally known producer’s studio playing fifteen-plus world instruments, years as a spoken-word and slam artist including shows with Taylor Mali and a three-hundred-student university performance, a national drum-and-bugle championship, a standing weekly residency and three years on the main stage of a city Irish festival drawing over twenty thousand people, and eight years as a performing bard with appointed titles, competition wins across kingdoms, and closing-ceremony sets in front of crowds in the high hundreds. That’s past tense and I’ll say so plainly — I haven’t performed publicly in about fifteen years. It’s here because room command turned out to be one continuous skill from a teenage stage to a state funding pitch, and it doesn’t show up anywhere in a list of systems.

How I actually work

I direct AI agents to write the code and I hold everything else. Planning and building are deliberately separate phases with an explicit gate between them. Anything touching payment, authorization or an agent loop goes through an adversarial review panel plus an independent blind pass, with the proposed fixes attacked as hard as the findings — because a review is better at finding problems than closing them, and a false all-clear is the most dangerous artifact a review can produce. That process has caught real live vulnerabilities: an authorization hole in a cancel path, a redaction gap leaking card numbers typed with separators, a concurrency double-booking race.

Two rules carry most of the weight. Built green is not works live — a passing build, a passing suite, even a passing review prove nothing about runtime behavior at a deploy boundary, so the real gate is loading the deployed URL and exercising the actual thing. And when a bug keeps resurfacing through different code paths, that’s a missing invariant, not a series of unrelated patches: install it at the single choke point and pin it with a test that fails if it’s ever violated. Every git operation on every one of these systems is mine, by hand.