The design principle: assume the instance dies, and make sure the intelligence was never in it. Biology has a name for this pattern — stigmergy: termites coordinate not by talking to each other but by leaving traces in a shared, durable medium. Any individual can die mid-build and construction continues, because the intelligence lives in the environment, not the organism. Same move here: the entire system lives in plain, human-readable files on a substrate you own. The model is the current reader of the record — never its keeper.

The stakes are highest exactly where the value is highest — the long-horizon work from Pt. 0. A methodology codification runs for years and should outlive every tool it was built on. An account’s accumulated brand judgment is a client asset, not a subscription feature. If that work accumulates inside one platform’s memory, it’s hostage — to pricing changes, to deprecation, to an export button that may or may not exist. Own the substrate, and the work outlives the entire stack it was built on.

Migration then becomes a protocol instead of an emergency: export everything, audit the export for completeness against the source — assume it’s lossy until proven otherwise; mine was, twice, and I only know because I checked — then point the new model at the same files. I’ve now run this three times in eighteen months. A framework built over a year ago runs on today’s models without modification.

The side effect nobody prices in: capability upgrades become free. Every model improvement is just a better reader of the same corpus. You’re never locked into yesterday’s model to protect yesterday’s work — which inverts the usual platform-dependency math entirely.

If your AI platform disappeared tomorrow, what would your team actually still have?

The thing your documents describe — a person’s judgment, a client’s strategy, a team’s standards — keeps moving. The field is a living thing, and a static snapshot of it is accurate the day it’s written and quietly wrong within a quarter. The failure mode isn’t missing information; it’s undated, unversioned, contradiction-blind accumulation that no one trusts enough to treat as load-bearing.

The map has to be as revisable as the subject is mobile. The working disciplines, all cheap:

• Version everything, visibly. Every revision opens with a dated one-line note of what changed. Drift becomes auditable instead of ambient.

• Import ≠ integration. New material lands in a staging area and gets held against the current architecture before it touches anything load-bearing. A pile of ingested documents is not a knowledge system — it’s a pile with search.

• No silent overwrites. When new work contradicts what’s documented, the conflict gets named and classified — new information, earlier error, or genuine change of direction — and decided. Never quietly resolved in either direction.

In practice: a client’s brand isn’t a fixed spec, it’s a living identity — refreshed guidelines, a new sub-brand, a mid-year strategy pivot. A brand model built once and never maintained is wrong within two quarters, and silently wrong, which is worse than absent. These disciplines are what let encoded judgment track a moving client instead of fossilizing — and the contradiction protocol is where the system earns real trust: when new creative direction conflicts with the documented strategy, that surfaces as a named decision for a human, not a silent coin-flip over which document the model happened to weight.

Here’s the honest version of the cost, because this is the unglamorous post in the series: none of the above is technique — any of it is an afternoon to set up. The real price is sustained curatorial discipline: the standing decision that the documents are load-bearing, honored every session, including the ones where you’d rather just get the output and close the tab. Whether that price is worth paying depends on how often the same expertise gets re-spent instead of reused — which is worth actually counting before deciding.

When did your documentation last disagree with reality — and which one won?

Instructions are brittle for the same reason judgment is hard to delegate: you can’t enumerate it. Tell the model what to do and it complies in the cases you listed, then reverts to generic everywhere else — and everywhere else is where the real work lives.

A sufficiently precise description of how someone thinks functions as a program: read in one direction it’s a portrait; executed in the other, it’s configuration. The model derives behavior for situations you never wrote down, because it’s operating from the logic that generates your decisions rather than a list of decisions already made.

Precision here means character study, not preference list. “Prefers directness” is a preference — it barely configures anything. “Reads hedged answers as incompetence, because vagueness signals the speaker hasn’t done the structural work” is a mechanism — and mechanisms generalize.

In practice: ask a senior adaptation or brand lead how they decide when a brand element can flex and when it’s inviolable, and you’ll get “it depends” — followed by an hour of stories. That’s not evasion; the judgment is real and non-enumerable, which is why it’s never survived being written down as rules. Documented as mechanisms — the why underneath each call, not the calls themselves — the system can make a defensible read on a format, a substrate, a market it has never seen, because it holds the logic that generates the decisions instead of a lookup table of decisions already made. That’s the load-bearing layer under “a system that can teach the practice” from Pt. 0 — you can’t teach a lookup table, but you can teach a logic.

The test of whether you’ve written it precisely enough: does the AI make the right call in a situation the documents never mention? When it does, you’ve engineered understanding rather than instructions. Fair warning — writing this document is genuinely hard, because it forces you to make explicit what you’ve only ever navigated by feel. More on why that difficulty is actually the payoff in the last post.

What’s one thing about how you work that a new teammate (or an AI) always gets wrong until you explain the why underneath it?

That capability is configured, not emergent, and it addresses the actual failure mode of skilled work. Nobody fails to know their standards. People fail to hold them — under deadline, when tired, when “good enough” starts quietly renegotiating itself. Self-negotiation is the default failure state of any solo or fast-moving practice, and no amount of model capability touches it.

The more useful configuration axis isn’t what the model can do — it’s whether your bar holds when you’re rushed, tired, or drifting. The fix is to write the standard once, explicitly, as named failure modes the AI checks for unprompted. Two directions:

• Checks on the output — is this generic, or does it reflect what we actually established? Is the reasoning built, or are bullet points substituting for it? Is agreement earned, or just accommodation? Did the thought finish?

• Interrupts on the human — the recurring patterns you already know about yourself or your team: scope creep dressed up as diligence, prerequisite side-quests burying the original thread, revision loops where “done” keeps moving. Written down with enough precision that the AI can recognize the signal, not the vague mood — that precision requirement is the entire trick.

None of this is exotic; it’s a checklist that runs every time instead of relying on someone remembering to ask for rigor. And it’s what turns the brand-evaluation case from Pt. 0 into something you’d actually trust: an evaluation tool is only as good as its weakest moment, and without enforced standards its weakest moment is whoever happens to be running it that day. With them, the newest person on the account works against the same bar the account lead would hold — the standard stops being a person and becomes a property of the system. On a three-year account, that’s the difference between judgment that scales and judgment that bottlenecks.

What’s one standard your team holds in theory that quietly slips under deadline pressure?

The cost of getting this wrong is the tax everyone pays without registering it: explain context, get output, close the tab, explain the same context again tomorrow. The work doesn’t accumulate — it evaporates. And replaying how you got somewhere is not the same as standing where you arrived.

What’s actually worth persisting is three things: decisions reached (stated as conclusions, not process), questions still open, and the current position of the work. The open questions are the underrated one — a live list of unresolved threads carries direction, which no pile of transcripts contains. The AI reads this state at the start of every session and writes to it at close.

In practice, this is the difference between a codification effort that ships and one that circles. Making a senior team’s expertise explicit isn’t a task — it’s hundreds of small decisions about how decisions get made, accumulated over quarters. Run transactionally, every working session re-litigates ground that was already settled, and the effort stalls at the size of what one person can carry between meetings. Run against a live state document, every session opens where the field currently stands — settled things stay settled, open questions stay visibly open — and the methodology grows instead of churning.

The payoff generalizes: a framework built six months ago is still load-bearing today without anyone re-deriving it, and sessions begin at the level of the work instead of the level of orientation. The mechanism is almost embarrassingly low-tech — one living document. But the value isn’t the document; it’s the discipline of the write. A session that ends with its decisions unrecorded didn’t compound. It just felt productive.

What did your team settle months ago that someone would still have to re-derive from scratch today?

The inversion: instead of building better infrastructure around the model, encode the practitioner — how a specific person thinks, decides, holds standards, and fails — into a persistent set of documents, and treat that encoded judgment, not the model, as the asset.

The test that separates the two frames: does it survive a platform change? A great prompt dies in migration — it was tuned to its model. An externalized model of how a person thinks transfers to any sufficiently capable model with near-zero fidelity loss, because it was never in the platform to begin with. I’ve run that test three times. It held. (Two things it isn’t, while we’re here: not a fine-tune — the model doesn’t change — and not a persona prompt — nothing is acting. It’s documents a stock model reads and operates inside.)

Where this pays off is the work that usually gets labeled “too nuanced for AI.” Three concrete shapes:

• Codifying a methodology that currently lives in one or two senior heads. The result isn’t a doc dump — it’s a system that can teach the practice to someone new, and check work produced under it against the real standard, without the senior people in the room.

• Client and brand onboarding — the account’s voice, history, and standards as a standing profile every session reads at start. Result: no re-briefing, ever. Session one of a new engagement starts with the senior lead’s head already loaded.

• Brand evaluation — work assessed against a standing, explicit model of what “on-brand” means for that client, not a generic rubric. Result: the most experienced person’s judgment, available at 4:45 on a Friday when they’re not.

What those three have in common: each is a living body of judgment too large and too interwoven for any one person to hold in view at once — which is exactly why it’s tacit, and exactly why it walks out the door with the people who carry it. This frame treats that field as the thing you build. The AI is what holds it at working fidelity. That’s the category the next few posts unpack, one working part at a time.

What’s one judgment call on your team that currently lives in exactly one person’s head?