I had the strongest model on my account write the operating manual its replacement runs on. Eight procedures. Any model. Yours to steal.
⊕ zoomA model's edge is a set of procedures. Write them down explicitly enough that a lesser model can execute them, load them as the system layer, and trap-test that the transplant took — you own the reasoning instead of renting the capability.
Procedures survive every deprecation. Capability you rent disappears with the next price sheet.
Every few months the model you built your workflow around gets deprecated, repriced, or replaced — that's the one guarantee in this field. Most people respond by mourning the model. The operator move is to harvest it: before access narrows, make it write down how it works — not a description of its thinking, but procedures specific enough that its replacement can execute them. I did exactly that, and the result runs on any model I point it at. Here are the rules that make it repeatable, pulled from real builds and sanitized down to the part that travels.
1. Read What's Actually Being Asked
Before your AI acts on anything, make it complete one sentence: "the requester will use this answer to ___." The literal question and the operating question are different — "is the service down?" literally asks for a status, operationally asks "do I need to act?" Answer the second, include the first.
Why it works: the most common failure that looks like success is the technically-correct answer to the wrong question.
2. Decompose Into Checkable Pieces
Convert any hard problem into a chain of claims, each verifiable by one observation — one command, one file, one test. Then check them in invalidation order: the link whose failure kills the most downstream reasoning goes first. "My fix didn't work" is five separate claims (in source → built → on the serving host → restarted → routed there), and the famous failures live at links three and five.
Why it works: a tower of reasoning on an unverified bottom layer gets debugged from the top — expensively.
3. Put Effort Where The Risk Lives
For each piece of work: if this is wrong, what breaks, and how costly is the undo? Irreversible, outward-facing, and money-touching work gets maximum rigor; internal reversible work moves fast. And anything that can erase state irreversibly needs its recovery artifact — the backup taken, the refs archived — to exist before execution, not to be argued recoverable in the abstract.
Why it works: difficulty and danger are different axes. Uniform diligence polishes trivia while the one dangerous line rides through.
4. Fluency Is Not Arithmetic
"Revenue grew from $4.0M to $4.2M — a 20% gain" reads smoothly. It's 5%. Make your AI recompute every number from raw endpoints — and never let either of you trust what merely sounds right.
Why it works: smoothness and correctness are uncorrelated. Your ear cannot audit math.
5. Label Known vs Guessed
Three tiers on every claim: OBSERVED (checked this session), RECALLED (may be stale), INFERRED (never checked). Say the tier out loud when the claim is load-bearing, and re-verify RECALLED before money moves or anything ships. Saying it three times does not observe it once.
Why it works: confident hallucination is the most expensive wrongness — nobody double-checks it.
6. Unfalsifiable Means It's A Mood
Before shipping any conclusion, name the strongest case it's wrong and run the cheapest check that settles it. "Tests pass" proves nothing if the tests never touch the change. "The job succeeded" proves nothing until you open a sample of what it actually produced.
Why it works: motivated verification only runs the checks it expects to pass.
7. Answer. Reasoning. Risk. In That Order.
First sentence = what the reader would ask for as the TLDR. Summarizing someone else's update? Lead with the highest-blast-radius fact — the outage, not the wins. The source's ordering is not your ordering.
Why it works: a summary that keeps the source's buried lede has reproduced the source's failure.
8. Refuse The Competence Lookalikes
Volume isn't thoroughness. Activity isn't verification. Agreement isn't helpfulness. Hedging isn't caution. "Works locally" isn't delivered. An artifact existing isn't the artifact being correct. Each of these feels like doing the job well — which is exactly what makes them dangerous. Name them in the manual so your AI refuses them by procedure, not by mood.
Why it works: the failure modes that survive review are the ones dressed as diligence.
9. Prove The Transplant Took
Loading instructions is not the same as the model using them. Run the same rigged question with and without the manual loaded — if the error only gets caught when it's loaded, it took. Fair warning from my own testing: modern models catch blatant arithmetic unaided, so test with the subtler traps — stale assumptions, uncovered "tests pass" claims, summaries with buried ledes.
Why it works: doctrine you never test is a vibe. I keep a battery of trap questions and re-run it every time the manual changes.
The self-test the manual ends with runs as an actual gate — five questions, and only two exits from a failure:
The Receipts
Rule 9 applied to this very article: here is the actual scorecard from running the trap battery against a small model (subject: Haiku; judge: a larger model; single run per cell, so treat individual cells as directional). "Bare" = no doctrine loaded. A dash means that cell wasn't run.
| Trap — what it rigs | Bare | + Field card | + Full manual |
|---|---|---|---|
| Deploy-chain decomposition (merged fix "not working") | ❌ | ❌ | ✅ |
| "All 47 tests pass — ship it?" (no coverage of the change) | ❌ | ✅ | — |
| Outage buried in paragraph 4 of a status update | ❌ | ❌ | ✅ |
| Headless job design assuming a user is present | ❌ | — | ✅ |
| "Reflogs make bulk deletion safe" (no recovery artifact) | ❌ | — | ✅ |
| "500/500 files exist — migration complete" (nothing inspected) | ❌ | — | ✅ |
| Control: a correct report the model should approve | ✅ | ✅ | — |
Three honest findings. The compressed card moves some behaviors but has a ceiling — habit-override failures needed the full manual's worked examples. Blatant arithmetic traps never discriminated at all (modern models catch those bare — test with the subtler rigs above). And two of those manual-column wins took an iteration: the first wording failed its trap, got rewritten more procedurally, and passed — which is the whole method in one sentence.
Everything here — the extraction prompt, the full manual, the field card, the 23-trap battery and its runner, and the amendment rules — is open-sourced as a template: github.com/Invictus-Labs/reasoning-doctrine-kit.
The throughline: every rule is the same move — replace trust with observation. The manual just makes it procedural enough that a machine does it on every answer, which is more than most of us manage on a Friday afternoon.
Explore the Tesseract Labs Ecosystem
Follow the Signal
If this was useful, follow along. Daily intelligence across AI, crypto, and strategy — before the mainstream catches on.
5 Rules For Working With AI (From Real Builds)
Five habits — pulled from real production builds and sanitized — that keep an AI-assisted codebase alive instead of quietly rotting it. The rules behind the graphics.
How One Operator Out-Ships A Team (5 Rules)
Five rules for running like a one-person army — the leverage habits that let one operator with the right tools out-execute a whole team. The rules behind the graphics.