Everything here was built with AI. So the way I direct it is a product I built too.

The problem showed up around hour forty.

Every product on this site was built with Claude. That is the authorship claim and it goes in the first sentence, not the footnotes — directing an AI to produce something genuinely good is the whole skill, and it is nothing like typing prompts.

But past a certain volume a second problem appears, and it isn't the one people expect. A wrong answer is easy: you read it, you catch it, you move on. What actually costs you is drift — context lost between sessions, a decision re-litigated because nobody wrote down why it was made, a fix that quietly regresses three weeks later with every test still green.

So the process became a product of its own — and it is built, not just written. 297 safety rules inventoried. Ten keyword workflows that open and close every session identically. 30 scripts and six interception hooks enforcing the parts a person forgets. And the tests below, checking that any of it is actually happening.

It has its own repository, changelog and bug log — 797 commits as of 2026-09-02, which carries a date for the same reason the guard count does.

One number in there is worth stating before someone else works it out. About a quarter of the total went into the contract rather than into the products — 56 hours against the finance app's 75, through August. That is a real trade and I would make it again: the contract is why the third product did not cost what the first one did, and it is the only reason a session can be interrupted, resumed a week later, and pick up the same argument.

But it is a quarter of the time, and I hold it to that. A process that grows faster than the work it serves has stopped being a process. So the contract has a ratchet on its own size that fails the build when it grows, and the rule that got it there is the same one everything else here runs on — measure it, then argue with the measurement.

The workflows are the unglamorous half and they do the most work. One opens a session by pulling every repository and reading the handoff note the last session left. One closes it by rewriting that note, logging what shipped, and refusing to finish while anything is uncommitted. Three of them exist purely so that noticing something costs nothing — a defect, a tangent worth keeping, an idea — because the alternative is derailing the work to write it up, and the real alternative to that is losing it.

Ninety-one tests that don't test the software.

They test whether the way I work is being followed. Whether a rule that exists in two documents still says the same thing in both. Whether a safety check that is supposed to refuse an action actually refuses it. Whether a number quoted in one file still matches the file it was quoted from.

Two of them have gone red, and the count stays on this page on purpose. I changed the contract and didn't re-baseline the checks that watch it, so they failed — which is the guards doing exactly their job. Both were closed the same day. A dashboard that only ever shows green has stopped being an instrument, so the red stays visible and the page says when it cleared rather than quietly turning green.

The rule underneath all of them comes straight out of the validation lab: a check that has never been seen to fail is not a check. So every guard gets deliberately broken, watched to go red, and restored before it is trusted. It costs a minute. It is the only thing separating a working check from one that cannot fail — and I have written checks that could not fail. Three of them printed a green tick on the same day.

Six of them, live — not screenshots. These are the working files, published as they were used. The comparisons animate, because a still of a comparison is not a comparison.

⛔ Round one is wrong and it is still published. A case study that shows only the corrected answer hides the part worth showing — which is not the answer, it is the fact that looking changed it.

A system an AI operates needs an interface designed for the AI.

The contract isn't prose the model reads and hopes to remember. It's a small, closed vocabulary — one word triggers one procedure. SUNRISE opens a session: pull everything, read the note the last session left, propose a first move. SUNSET closes it and refuses to finish while anything is uncommitted. BATON is its cheap sibling, for when the context is filling. DEEPAUDIT is a deliberate audit. GENESIS starts a project.

Three of them exist for one reason: so that noticing something costs nothing. FOUNDUX flags a design defect spotted mid-flow. TOAST keeps a conversation that turned out to matter. SPIN catches an idea worth having but not chasing. One word, one line of acknowledgement, and the work continues. They were designed around the failure they prevent — derailing to write something down — and the worse one behind it, which is not writing it down at all.

The words are the interface, so they were chosen like one. Single tokens, because they get typed mid-sentence and have to cost nothing. Unmistakable, because a keyword that isn't recognized does nothing and says nothing — the silent failure again, this time in the command layer. FOUNDUX is found + UX: it says what it captures, which is what makes it come back a week later when you need it.

The same instinct runs through the rest of it. A refusal has to fail closed: the list of repositories that may never be published is read by three separate tools, and a missing list refuses everything rather than allowing it. A folder holding material that must never be published is named IGNORE — not because a rule says so somewhere, but because a gate that depends on being read is a gate that gets missed, and a name is read by everyone who sees the directory.

And the vocabulary stays deliberately small. Five section headings, five inline markers, and each one had to prove it was needed repeatedly before it was allowed in. Five is a vocabulary. Fifteen is decoration — and a system that keeps adding symbols is one nobody can hold in their head, whether that head is mine or the model's.

The rules that get broken most often are the ones I took out of the rulebook.

An instruction file is delivered to the model once, at the start of a session, and never repeated. A different mechanism — an output style — is placed in the system prompt and re-asserted as the conversation runs. Those are two very different delivery channels, and which one a rule sits in is a design decision nobody was making.

So I split the rules by where they fail rather than by topic. The handful with the worst compliance record — verify before asserting, say the tradeoff out loud, test the check by breaking it — moved to the channel with the strongest delivery. The ones that rarely fail, like where a file lives or what a marker means, stayed where mere availability is enough.

That sentence is there because the alternative is worse. An improvement nobody can measure, described later as a success, is how a team ends up defending something that never worked. Writing down what you don't know costs nothing at the time and is the only thing that survives contact with the next person.

An empty dashboard gets investigated. A confidently wrong one does not.

The usage dashboard behind the numbers above refuses to report its edit count as a total, because an entire category of edits is invisible to it — and it says so, on the page, next to the number. It also turns red and declares itself stale if the job that generates it stops running, because a page that auto-refreshes looks identical whether the data is live or frozen since March.

This is the same instinct as seven years of validation work, pointed at my own tooling. The dangerous defect was never the one that crashes — that one announces itself. It's the one that produces a confident, wrong answer while every test passes.

Which is exactly what a large language model does when it doesn't know something. That is the gap I sit in. Not that I can get output out of an AI — everyone can now. That I have spent a career deciding whether work that looks fine actually is, and I point it at my own output first.