ECO

My biggest project, and the one I’m proudest of. In active development since March 2026 — 267 commits deep, 677 Rust tests passing. It’s not finished, and I’m not going to pretend it is. That’s the point of putting it here.

The job. When a build runs long and the work gets complex, it goes sideways in the same few ways every time. Different AI models end up touching the same code — ChatGPT, Claude across versions, Sonnet, the agents I’ve named — and it still has to read like one hand wrote it. The truth about where things stand gets scattered across chat windows that vanish the moment you close them. And the second you let the agents run themselves, you lose the thread on what was actually checked. ECO is the control plane that keeps all of that in line: one verified place where the truth lives, the human as the final word on every commit, every decision, every risk, verification proofs treated as real artifacts with their freshness tracked, and a bounded run → write-back → re-run → mark-verified lifecycle that’s approval-gated, not turned loose. No off-the-shelf tool does this. That’s why I had to build it.

What’s mine. Nearly all of ECO is my design — the Tauri desktop shell, the Rust backend, the SvelteKit front end, the SQLite store with full-text search, the indexer that reads my existing folders without moving a file. The code itself is AI-written under my direction and my checkpoints; the architecture, the calls, and the governance are mine. It all runs local, on my machine, not someone’s cloud. And the governance itself, which I’ve now built twice. The first version was the rulebook written as Markdown docs and prompts, with the AI told to read them and behave. That works partway — but rules in a doc can be skipped, forgotten, or argued around. So the version I’m building now codifies the same rules into the Rust itself: the sign-offs, the tier classification, the bounded lifecycle, the proposal-to-write-back flow, the freshness tracking. Once it’s in the binary, the agent can’t talk its way past it — it has to go through it. Rewriting governance from “Markdown the AI is supposed to follow” to “Rust the AI has to pass through” is slow work, and it’s why ECO is still going.

What I wired in. Less than the other projects — but not nothing. There’s a provider layer so ECO can run against mock AI or live, and swap between vendors: Anthropic is the daily driver, but there’s a proven live run on OpenAI too (VERIF-182), so this one isn’t tied to a single AI company. Past that, it’s all original — my design, built by AI under my checkpoints, not glued together from other people’s tools.

How I ran it. The agent setup isn’t a quirk — it’s the shape complex work needs. Any well-run shop splits it the same way: someone plans, someone builds, and the boss signs off on both. ECO is the desktop app that lets me work like that with AI. I run two of Anthropic’s agents under role prompts I wrote — one I named Talos for strategy and audit, one I named Effy for the build — and I hold final say over both. The agents are off the shelf; the framework around them — the roles, the separation, the rules, the checkpoints — is mine. Every task goes through that checkpoint discipline, and the pre-commit review is a hard stop. Nothing gets committed without my sign-off.

The receipts. 267 commits since March, and a verification log that’s the real spine of the project — 450-plus numbered proofs, each one noting what it does and doesn’t prove. One example of the discipline: I cut the app’s main screen from ~8,912 lines down to ~1,959 today, across thirteen passes, each one regression-proven before I moved to the next, no “trust me, it still works.” Those receipts live in the verification log, not in git history. And the whole governed lifecycle — run, write back, re-run, mark verified — is proven end to end, under both a mock AI and a live one. That’s not a demo. That’s the thing working.

Why it counts. It’s the biggest thing I’ve built, it’s not done, and it’s solving a problem I couldn’t find solved anywhere else. Building it is how I learned to keep a long, multi-agent job coherent, keep a human in charge of every call, and prove what’s been checked instead of hoping. If a client’s got a build that’s going to run for months across more than one AI, this is the kind of control I bring to it.

Tauri, Rust, SvelteKit, and SQLite with full-text search.

Got a long build that has to stay coherent across more than one AI? Let’s talk about the job →