Most of what gets said about AI and code is about speed. The speed is real, and so is the rubbish that comes with it, and the only difference between the two is whether somebody read the thing before it shipped. So I run agents the way I run a build. There's a written brief, a done-state I can check and a set of gates that fail the work, and I read every commit before it merges.
It starts with a prompt that argues back
Every non-trivial request goes through a rule in my global config that I call the prompt amplifier. The agent sorts the job into one of nine modes: build, ship, debug, review, research, plan, refactor, design or operate. It asks me three to six questions in a single batch, never one at a time, and then rewrites my request as a full specification.
The specification has five parts. A mission that says what done and failure look like, a phased protocol, at least five forbidden behaviours, a rubric of six checks or more, and the literal first command. I read it, change it and sign it off, and nothing runs before that. If I tell it no questions, it still restates the task in one sentence first. If the scope moves halfway through, it writes the change up as a new specification and waits for me.
One coordinator, workers in parallel
A coordinator holds the project and its memory. Each job gets its own thread, workers run in parallel across repositories and branches, and what one of them learns goes into shared memory so the next one doesn't ask me the same question again. They can read and edit folders on my own computer and drive my browser for dashboard work. I sign in myself, and the steps that touch production wait for me.
The Fiserv payment work ran in stages: research, review, code, apply and flagging. The agents saw test credentials and sample data only. What they flagged or couldn't solve I hand-coded, and I entered the real data myself once it was confirmed working. inclusive.io went the other way. I wrote the specifications, sketches and initial designs, a fully engineered prompt turned them into code, and I reviewed every commit and every section by hand.
The build is set up to fail
A rule an agent can ignore is a suggestion, like a wet floor sign in a building with no mop. So the rules that matter are gates, and a red gate stops the deploy. This site runs twelve before the build and two after. They check types, lint, contrast, colour tokens, voice, claims, facts, copy that reads as machine-written, the Quoin benchmark data and llms.txt, then colour space and bundle size.
- The slop gate scores my own copy against thresholds taken from published detection work: negated contrast, polished triplets, sentence-length variation, style words and empty openers. It counts the rate rather than the presence, because a person uses those devices now and then and a model uses them constantly.
- The claims gate exists because I found three surfaces still asserting something I had already retracted. It holds the pages that say what I am to the settled position, and leaves the case studies free to tell the story of getting it wrong.
- The facts gate keeps every number the site states about itself in one file. Any page that states a different value fails the build.
- The corpus gate checks the published Quoin benchmark table against what was measured. The old table had been typed by hand and had drifted before anything compared it.
- A built-site suite runs keyboard use, focus rings, axe on every page in both designs, layout at five sizes, the back and reload rules and every internal link, against the built site.
I trust the gates over my own reading, and I have the receipts. One audit pass reproduced and fixed seven defects in code I had written, reviewed and shipped, including a toolbar that had never worked once. Reading the code had agreed with me every time.
What it leaves behind
Handovers carry each decision to the next agent with a link to the session behind it, so a fresh one can pick up cold. Prelight, the layout linter I've now shelved, ran to a 70 KB handover. A skill called task-observer logs where another skill let me down, and I review the log weekly. What the agents learn about how I work goes into AGENTS.md, and a 947-line voice document built from my own diary, captions and email keeps what they write sounding like me.
About 60 skills are installed, mostly from gstack: office hours, specification, plan reviews, design and code review, QA, a security audit, benchmarks, canary and release. Claude Code does most of the work, Codex did before it, and I call the OpenAI and Anthropic APIs from my own code. Qwen and DeepSeek are fine-tuned and run on my own machine with Unsloth and Docker.
The agents are the labour. I'm the project manager and the consultant, and the gates are the part that doesn't get tired.
Prelight reached a 440-test suite and 98.8% agreement with real Chromium, WebKit and Firefox before I shelved it. inclusive.io has 117 components, 1,564 end-to-end tests and 0 axe violations across 174 routes. None of that came from asking nicely. It came from a brief, a rubric and a gate that could say no.