How I build agents
that survive production.

Nothing reaches production by push-and-pray. A change moves through a fixed sequence: build locally, pass a pre-push gate, deploy to the live box with the rollback image armed before the new one goes up, then run a smoke test that exercises the real code path, not a stand-in. Each step that touches production is a discrete, explicit authorization, not an implied continuation of the last one.

The point of the ladder is that at every rung there is a known-good state to fall back to and a defined signal that says go or stop. When a deploy is healthy you continue; when it is not you roll back to the armed image in one step. Boring, on purpose. Boring is what you want holding a live system.

The most dangerous test is the one that passes for the wrong reason. If the environment your tests run in does not match the environment your code runs in, a green suite is telling you about a system that does not exist.

I do not point a new agent at production and let it run. The first live action is deliberately tiny and reversible: a single bounded operation, graded against the spec, with idempotency proven by running it a second time and confirming the second run changes nothing. Only then does the recurring schedule go on. Only after that does any state-mutating behavior get enabled, behind its own gate.

Every step is chosen so its blast radius is understood before it runs and its undo is known. Small and reversible beats big and irreversible, every time, especially when the thing acting is a machine on a timer.

An agent that runs unattended has to be safe by construction. The agents I build carry fail-closed spend ceilings, atomic claims that make duplicate actions structurally impossible, idempotent append-only writes, self-recovering locks that prevent overlapping runs, and a rollout switch with off, shadow, and live states so behavior can be observed before it is armed. Anything the agent is uncertain about is routed to a human queue rather than guessed at.

These are not features I add at the end. They are the shape of the agent from the first commit, because they are what let it be trusted on a schedule.

Code that checks itself tends to agree with itself. So the live behavior of an agent gets graded by a fresh, independent pass that is given the spec and the actual output, not the implementation, and derives what the result should have been on its own. That separates "the code believes it is correct" from "it is correct."

It is the same instinct as the negative control: trust is something you demonstrate, not something you assert.

When it came time to describe these agents publicly, I ran a code-grounded audit of every claim and cut the ones the code did not support, including capabilities that sounded good and were genuinely on the roadmap but were not yet built. A capability is what a system does, not what a slide says it does.

If you are evaluating me, that is the part worth weighing: I would rather show you a smaller true thing than a larger claim that falls apart the moment you read the source.

I build with Claude Code doing the execution and me holding the judgment. Anything that touches production, credentials, deployment, or irreversible state is a decision I make explicitly, not something the tooling does on its own momentum. On a recent build the tooling itself refused to arm a live flag change because it had not been given explicit human authorization, which is exactly the boundary working as intended.

My own trading product is the clearest example. Its optimization engine runs the strategy's parameters through many rounds against years of history and writes up the strongest candidates as proposals, complete with reasoning and exact changes, but it cannot touch the live strategy on its own. Every proposal waits for me to approve or reject it with a reason. The machine does the heavy analysis; the human makes the call.

The skill I am actually selling is not typing code. It is knowing what to build, where the risk sits, and how to bring an autonomous system into a live environment without breaking it. Claude Code makes the building fast. The judgment about how and when is the job.