How I Built This

How I run products through agents

Every product I ship runs on an operating model I designed: agents with defined roles, gated handoffs, explicit model routing, and automation that runs without me. This is how it works.

The ship flow

One GitHub issue in, one verified live change out. I can rerun it on any issue on demand. Every arrow is a gate, and gates fail closed: a missing check blocks the ship, it never counts as a pass.

Model routing

Claude Opus

Default for everything: planning, building, reviewing, most analysis.

Claude Fable

Pinned only to the hard stages: from-scratch reasoning and red-team passes, where a different model adds real value.

GPT via Codex

Implementation of a tightly scoped task, inside a Claude plan and a Claude review.

No single-model dependency: every stage has a defined fallback, so a capacity limit on one model reroutes the work instead of stopping it.

Agents as builders, scripts as runners

An agent is great at figuring out a task the first time and expensive and variable every time after. So once a task repeats, an agent writes it into a deterministic script on a schedule. The script costs zero tokens per run and behaves the same every time. Agents stay at runtime only where the job needs judgment.

What runs unattended

Repeatable work runs on schedules without me, and every scheduled job reports into a weekly fleet review: runs, failures, and interventions, measured rather than assumed.

Trust the output, not the status

An agent's report of its own success is a claim, not evidence. Long-running agent jobs can time out after finishing, or report success on partial work. So critical agent jobs get an independent watchdog: a plain script that checks the real output and self-heals or alerts. Oversight is built into the system, not left to the agent.