Process
Vibe coding, with the safety brake still on.
People hear "AI wrote the code" and picture a fire-and-forget agent. That's not how this works. The tooling is fast — Claude Code, Cursor, testnet, paper mode — but the operator stays in the loop the whole time. Design in plain English. Adversarial verify before shipping. Never let the machine close the loop alone.
The loop
Six steps. Repeat until the alerts go quiet.
01
Start with a real problem I actually have.
Every system on this site started as a personal wall — a grid I wanted to run without babysitting, a portfolio I couldn't see all at once, a research loop I wanted to spawn overnight. Not product ideas. Frustrations with sharp edges.
02
Design in plain English, out loud, before code.
I open Claude and describe the shape: what state matters, where the money can move, what has to stay true when something goes wrong. Constraints first, features second. If I can't explain the safety envelope in a paragraph, I'm not ready to write the first line.
03
Build the smallest slice that proves the idea.
Not a full system — just the one path that touches the risky part. For Trellis it was the reconciliation engine: can I place, cancel, and heal a grid against a live book without leaving orphan orders? Everything else waited until that one loop was rock solid.
04
Adversarial verify before anything ships.
Before I trust a fix, I spawn a second agent whose only job is to try to refute it. Different framing, cold context, no memory of what I just decided. If two skeptics agree it's real, it ships. If they don't, I re-open the question — not the fix.
05
Paper first, testnet second, live last.
Every trading system lives in paper mode by default. Then testnet with real venue mechanics. Only after the market checks — fees, spread, depth, range — pass on live data does the operator actually approve a live start. Live is a gate, not a default.
06
Ship, then watch it.
The command layer (Nexus) is where every live system reports in. Positions, P&L, circuit-breaker state, process health, one screen. If something drifts, it pages. If it crashes, it restarts. The work isn't done at 'live' — it's done when the system runs unattended and I trust the alerts.
The honest part
I'm not writing kernel drivers. This stack is Python, TypeScript, and paper-first trading. The edge isn't cleverness in any single line — it's discipline about the loop: what runs paper, what runs live, and what has to be true before anything moves.
Why it works
The advantage isn't typing speed. It's knowing which problems are actually worth shipping.
A demo that looks great in a screenshot but silently drifts in production is worse than nothing. So the whole loop is built around never trusting a green tick without evidence: paper mode, testnet, adversarial verify, live only after checks pass.
AI writes the code. The operator picks the fights, sets the boundaries, and stays on the alerts. That combination is what lets one person run a stack of live crypto systems without waking up to a smoking hole.