REBUILT WILD / BUILDING WITH AI

85 of my 122 rules were paper.

I audited every rule I'd written for my AI agents against what actually fired that morning. The count, the dead gates, and the one change that fixes the most.

Ken Jackson / November 13, 2026 / 8 min read
A row of paper checklists clipped to a dark wall beside a black steel turnstile with a glowing red light.
On this page
  1. Three labels
  2. The fixes that did nothing
  3. A rule can be in the file and not in the head
  4. Adopt before build, written the right way
  5. The one change
  6. What to take from this

At 8:15 on Friday morning I wrote this to my agents: the designer check was a rule on paper.

I'd written the rule. Builds had still gone out without a designer's comps, and I'd been grading them F all morning. I asked how we enforce the right things. The question underneath that one was simpler: which of my rules enforce anything today?

An auditor agent answered it, from 9:36 to 9:53 AM. The ground rules were strict. Evidence only from that day: hook events, scheduled-job state, logs, CI run lists, HTTP probes, file searches. Nothing could be taken from a claim in a document.

Three labels

Every rule got one of three labels.

  • Enforced: a mechanism exists and fired that day.
  • Partial: a mechanism exists, but it isn't wired, isn't running, or can be bypassed.
  • Paper: no mechanism at all. The rule is a sentence.

It checked 122 rules.

122 rules, checked against what fired that morning
  • Enforced 5
  • Partial 32
  • Paper 85
Paper-vs-real audit, 9:36 to 9:53 AM, November 13. Of the 19 rules behind that day's F grades: 0 enforced, 6 partial, 13 paper.

Five were enforced. Thirty-two were partial. Eighty-five were paper.

The worse number is the next one. Nineteen of those rules sat behind the F grades I'd handed out that day. Zero were enforced. Six were partial and thirteen were paper. The rules I cared about most were the ones with the least behind them.

A rule with no mechanism is RED the day it is written.
Paper-vs-real audit, November 13, root-fix line

The fixes that did nothing

I expected paper. I didn't expect fixes I'd already marked done to be dead.

  • A guard on 1Password command-line use sat behind a hook whose matcher didn't include shell commands. It never saw the commands it was built to stop. A counter that flags a Claude session making too many tool calls without handing work to Codex lived in the same hook and had the same blind spot.
  • Brief lint, the check that reads each task brief before an agent starts, was running in warn mode. Of 276 briefs that day, 198 had findings. It blocked none.
  • A stop gate meant to catch agents that quit without reporting had classed 1,568 stops as unreported. It stopped none.
  • The conformance check, which verifies that a repo uses the approved host and the approved UI kit, ran fine and was red on the main branch of five repos. It was a required check nowhere, so red didn't stop a merge.

Code existed for every one of those, and the auditor scored them partial for that reason. A label that says partial is generous for gates that did nothing that day.

A rule can be in the file and not in the head

The next finding was the one I couldn't have found by reading.

At the start of each session, a hook injects my operating rules into the agent. It injects up to 2,000 words. The main rules file is about 2,400. It was cut off partway. The three other files meant to load alongside it never arrived at all.

The rules reach the other coding agent only as a hand-edited text file, and the audit found the two copies already disagreeing. One pointed to a component catalog in one folder, the other to a different folder.

Five pairs of rules contradicted each other outright, so an agent could obey one and break another. In one pair, a file tells agents to ignore the old system's paths while another tells them it's the live system.

Adopt before build, written the right way

At 9:59 that same morning I added a rule: before we build anything, check what we could adopt off the shelf. Three to five candidates, open source first, a license check, and a decision. Adopt, build on, integrate, or build, and build only with a stated reason that nothing fit.

I want to point at how that rule was written, because it's the first one that came out with its mechanism attached. The section is headed "enforced, not paper". It says brief lint blocks a build brief for a new capability that has no off-the-shelf section, and that the Codex runner refuses it.

That's better than a bare sentence. It also leans on brief lint, and the morning's audit had just found brief lint in warn mode. A rule can name a mechanism and still be paper if the mechanism isn't switched on. Check that the gate refuses. Don't trust that it's described.

The one change

The audit ended with a short list of root fixes. Two stood out.

The first is a hook entry. One matcher covering shell commands and file edits would revive the secrets guard and the tool-call counter, and give a home to the guards for the Chrome app, scripted Instagram access, Cloudflare deploys and pushes to main. A few lines in a settings file, and the biggest cluster of dead gates comes back to life.

The second is a rule register. Every binding rule lists its source line, its mechanism, and the last time that mechanism fired. A watchdog marks any rule with no mechanism red on the day it's written. The audit itself was the register's first load.

I'll be straight about where this stands. These are the audit's recommendations from this morning. I don't yet know how many will hold.

What to take from this

  1. Write the mechanism with the rule, in the same document. If you can't name what refuses the bad action, you haven't written a rule.
  2. Count firings. A gate that has never fired might be perfect, or it might be disconnected.
  3. Test every gate by handing it something bad on purpose.
  4. Make the important checks required. A red check nobody is forced to read is a dashboard.
  5. Measure how rules reach the agent. Words that get truncated were never rules.
  6. Keep one source of truth and generate the other copies from it.

I'm rebuilding Cipher, my AI operating system, in the open, and this audit is part of that build. The next one will have a before and after. If you want to watch it happen, the live builds are on YouTube and Twitch.

Work with Ken

Want this running in your business?

Rebuilt Wild shows the work. Nexus Advisory is where we put it to work on your operation, starting with the workflow, not a software pitch.

More writing

Back to writing