Emit & Compound: the complete pattern

Institutional memory for businesses that run on AI — any tool, no code required.

The leak

A few weeks ago, mid-draft on a post I cared about, my AI handed me a statistic: “95% of AI projects fail.” Confident, round, quotable — the kind of number you nod along with. And invented: no source I use holds it. I caught it four seconds before it would have shipped under my name, to the exact audience I’m trying to convince I’m rigorous. I did what a careful person does — stopped, wrote myself a rule, cite it or cut it, and filed the rule in that day’s working folder. I remember feeling like I’d handled it well.

Two weeks later, a different draft, and there it was again. Not the same number — the same shape. A clean, unsourced claim presented as fact, four seconds from shipping. My correction hadn’t been ignored. It had been filed somewhere nothing ever reads — and the feeling of having handled it was the most expensive part, because it stopped me looking for the real fix.

If you run a business, you already know this leak — you just don’t call it a memory problem:

• Your best salesperson works out the objection-handling line that actually lands. It lives in their head. When they leave, it leaves.

• A support rep figures out the workaround for the billing glitch. The next rep rediscovers it from scratch, on a customer’s time.

• Your marketer learns which claim gets you in regulatory trouble. The new hire makes it again in their first month.

Now add AI, and the leak gets worse, faster. Every person in your business is having hundreds of AI conversations — drafting, summarizing, answering, deciding. Lessons are being learned in those conversations constantly. And they evaporate the moment each chat ends, because a chat is the working folder nothing ever reads.

The tools aren’t the problem. The model didn’t fail when it invented my statistic; models do that, and catching it took me four seconds. The failure was mine: the correction had nowhere durable to live. A lesson your system doesn’t re-read is a lesson you didn’t learn. You just felt like you did.

This is a process problem, and that’s good news

You don’t need a better model, a new platform, or an engineer. Institutional memory has always been a process: someone decides what’s worth keeping, writes it where people will look, and makes looking part of the job. Businesses that do this well have been doing it since long before AI — they called it standard operating procedure, or the house style, or “the binder.”

The only new thing AI changes is the speed: lessons now arrive constantly, from every seat, and your tools can be told to check the binder every single time — more reliably than any employee ever did.

That’s the whole pattern. Three moves. Everything else in this document is detail.

The three moves

Move 1 — One shared ledger

Everything your business learns from working with AI goes to one place. Not per-person notes, not per-tool memory, not a folder per project. One ledger.

It can be a Google Sheet. It genuinely can — the automated version I run (Appendix D) does nothing a spreadsheet plus discipline doesn’t do; it just does it without a human carrying things.

Each entry is one row, six fields:

date  ·  source  ·  type  ·  what we learned  ·  tag  ·  state
Jul 8  ·  Dana / sales call  ·  claim  ·  Lead with the integration story for dental offices — the compliance angle stalls first calls  ·  sales  ·  proposed
Jul 9  ·  AI draft review  ·  claim  ·  Never quote a market stat without a named source — AI invented one that nearly shipped  ·  marketing  ·  approved
Jul 10  ·  Support ticket #videos  ·  status  ·  Billing-glitch workaround documented and shared with the team  ·  support  ·  —
Jul 12  ·  Owner  ·  claim  ·  Don’t promise delivery dates in first-touch emails — ops can’t always honor them  ·  sales  ·  approved

That’s the entire data model. If your business never gets past a spreadsheet that looks like this, the pattern is still working.

Move 2 — Status vs. claim

The two type values above are the piece most people skip, and it’s what keeps the ledger from rotting into a junk drawer.

• A status is “this happened.” We shipped the proposal. The workaround got documented. Statuses are a log — useful for visibility, never dangerous.

• A claim is “this is true, and it should change how we work from now on.” Lead with the integration story. Never quote an unsourced stat. Claims are rules-in-waiting — and they’re dangerous until a human approves them, because a wrong rule gets enforced with the same reliability as a right one.

Anyone in the business can add either — that’s the “emit” half. Writing a claim into the ledger costs thirty seconds and requires nobody’s permission. But a claim starts life as proposed, and proposed claims have exactly zero authority.

When does something become a row? The working heuristic: the second time you correct the same thing, it’s a row. One correction is noise; the same correction twice is a rule trying to get your attention. Also rows: anything you catch just before it goes out the door (my invented statistic), and anything you hear yourself explaining to a new person that isn’t written anywhere.

And don’t start from blank. Before week one, seed the ledger in twenty minutes: write down the last three times you corrected an AI draft, the three things you repeat to every new hire, and the one mistake your business keeps almost making. That’s six to eight proposed claims — a real first review, not an empty ritual.

Move 3 — Approve → file → consult

Once a week, the owner (or whoever owns quality) spends ten minutes on the ledger’s proposed claims. Three outcomes per claim: approve it, edit-then-approve it, or reject it. That’s the ritual, and it’s the only approval step in the whole pattern.

An approved claim gets promoted to your house-rules page — a one-page document of the rules your business has actually learned, each one dated and traceable to the moment that taught it. This page, not the ledger, is what your AI tools read.

Then the closing move, the one that makes it compound: every AI conversation starts with the house rules already loaded. Not “employees should remember to paste them” — loaded automatically, using each tool’s built-in mechanism for persistent instructions (the appendices show exactly where this lives in ChatGPT and Claude; it’s a settings field, not a technical feat).

Do this, and the loop closes: a lesson learned in one seat, one tool, one Tuesday, becomes a rule every seat and every tool honors — permanently, with nobody carrying it.

If you’re thinking “we built an SOP wiki once and nobody ever read it” — that’s exactly the right objection, and it’s the one thing AI actually changes here. The old binder failed because reading it was a human habit, and habits lose to deadlines. This binder is loaded, not shelved: the tools read the rules at the start of every session because they’re configured to, not because anyone remembered. The discipline your SOP wiki needed from twelve people, this pattern needs from one person, ten minutes a week.

The weekly ritual, precisely

Because this is where patterns like this live or die:

Who: one person. The owner, or one named delegate. Not a committee — the whole point of the choke point is that someone with judgment and authority looks at every rule.

When: weekly, calendar-blocked, ten minutes. If you have more than ten minutes of proposed claims, your bar for proposing is too low — tighten it in the next review.

What to reject, ruthlessly:

• Claims that are really statuses (”we finished the migration” isn’t a rule)

• Vague virtues (”be more careful with numbers” — a rule you can’t violate isn’t a rule)

• One-off incidents that don’t generalize (”the Hendricks deal wanted blue” — that’s account context, not a house rule)

• Duplicates and near-duplicates — edit the existing rule instead

Why a human, always: it’s tempting to let the AI approve its own proposals — it’s faster, and the tools will happily do it. Don’t. A self-writing rulebook compounds noise exactly as faithfully as it compounds wisdom, and you won’t know which you’ve got until something ships wrong. The ten minutes of human judgment is not overhead on the system. It is the system.

Retirement: rules go stale — the market moves, the policy changes. Strike the rule through with a date and a one-line reason. Never silently delete: the graveyard is where new hires learn why the current rules exist.

The floor and the ladder

Run the floor version — shared sheet, weekly ten minutes, house-rules page pasted into each tool’s persistent-instructions slot — and you have the complete pattern. Zero engineering. This week.

Above the floor there’s a ladder, and each rung just removes a human hand-off:

• Floor: people add ledger rows by hand; rules load from each tool’s settings.

• Prompted capture: your AI tools are instructed (in those same persistent instructions) to end each significant session by proposing ledger entries — the AI drafts the claim, a human still files it.

• Automated capture: sessions write to the ledger automatically; proposals queue for the weekly review on their own.

• Automated consult: every AI task begins by automatically reading the current house rules — nobody pastes anything, ever.

The rungs change how much carrying humans do. They never change the three moves — and they never, at any rung, remove the human from approval. I run the top of this ladder every day; Appendix D shows you what that looks like with the actual logs. But I want to be direct: most businesses should start at the floor and stay there until the ritual is a habit. Climbing early automates a process you haven’t learned to run yet.

One more property worth naming: nothing in those three moves belongs to any AI vendor. The ledger is yours, the rules page is yours, the ritual is yours. Switch from ChatGPT to Claude — or run both, or whatever ships next year — and the pattern comes with you untouched. The tools are executors. The memory is yours.

---

Appendices — your stack

Appendix A: The ChatGPT shop

If you’re solo: the fastest slot is Custom Instructions — Settings → Customize ChatGPT. Paste your house-rules page into the free-text field. It applies to every chat automatically. Budget matters: the field holds ~1,500 characters on the free tier, ~5,000 on paid — a good forcing function, since a rules page that doesn’t fit in 5,000 characters has too many rules. When you do hit the wall (a healthy sign — it means the ritual is working), that’s your cue to graduate to a Project, whose instructions and files don’t share that budget — and to run the retirement pass: the wall is the pattern telling you some rules have earned a strike-through.

If you’re a team: use a shared Project, not personal settings. Create a Project for the business, upload the house-rules doc and the ledger to it, and set the Project instructions to something like: “Before any task, read house-rules.docx and follow every rule. If work in this chat teaches a lesson that should change future work, say so at the end and suggest a ledger row.” Project instructions apply to every conversation inside the project and override personal custom instructions; uploaded files persist for every chat in the project; and a shared project gives every seat the same rules without anyone maintaining their own copy. (That instruction’s second sentence is rung 2 of the ladder — prompted capture — for free.)

Why ChatGPT’s Memory feature is not your rules system: Memory is the model deciding what to remember about you, per account. It isn’t shared across your team, an owner never approves what goes in, and a colleague’s offhand phrasing can quietly become a “fact.” Useful for personal preferences; structurally wrong for house rules. Keep Memory on if you like it — just don’t confuse it with the binder.

Mechanics above verified against OpenAI’s help center July 2026 via search snippets (direct page fetch was blocked); exact button labels may drift — do one live click-through before you standardize your team’s setup doc.

Start today: ① Create the ledger sheet and house-rules doc. ② Solo: paste rules into Custom Instructions · Team: shared Project with files + project instructions. ③ Calendar the ten-minute weekly review.

Appendix B: The Claude shop

If you’re solo: two documented slots, use both. In Claude Cowork (Anthropic’s knowledge-work product), paste your house-rules page into Global Instructions — Settings → Cowork → Global Instructions — and it applies to every session. On claude.ai, create a Project for the business and put the rules in the project instructions, with the rules doc uploaded as project knowledge alongside the ledger.

If you’re a team (Claude Team/Enterprise plans): one shared Project is the whole mechanism. Create it, upload the house-rules doc and ledger as project knowledge, set the project instructions to the same read-rules-first + propose-lessons instruction from Appendix A, then set visibility to Public (org-wide) and give staff “Can view” — they get the rules and can’t drift them; whoever runs the weekly ritual gets “Can edit.” That permission split is the approval gate, enforced by the tool.

Why Claude’s memory is not your rules system: same verdict as ChatGPT’s, for the same reason — it’s a summary the model synthesizes about you from past chats, not a document an owner authors and approves. It also doesn’t carry between claude.ai chat and Cowork sessions. Useful ambient context; structurally wrong for house rules.

One honest flag: you may read elsewhere that Cowork automatically reads a CLAUDE.md file from your project folder. That’s a convention from Anthropic’s developer tooling that creator content often repeats — as of July 2026 it isn’t documented for Cowork in Anthropic’s official help pages. The mechanisms above are the documented ones; verify anything else in-app before your team relies on it.

Start today: ① Create the ledger sheet and house-rules doc. ② Solo: Global Instructions + a claude.ai Project · Team: one shared Project, Public visibility, view-only for staff. ③ Calendar the ten-minute weekly review.

Appendix C: The mixed shop

Half your team on ChatGPT, half on Claude — the most common real-world case, and the one that proves why the pattern lives outside the tools.

There is still exactly one ledger and one house-rules page (a Google Doc/Sheet both camps can open). Each tool loads the same rules page through its own mechanism — per Appendix A on the ChatGPT seats, per Appendix B on the Claude seats. The weekly ritual doesn’t care which tool taught the lesson: a claim proposed from a ChatGPT session becomes a rule the Claude seats honor, and vice versa. That cross-tool hop is precisely what per-tool “memory” features can never do for you.

One mechanical note that removes the last friction: both tools now speak Google Drive. ChatGPT (Team/Enterprise on Google Workspace) has a Drive connector that keeps synced content available, and Plus users can attach specific Drive files per chat; Claude’s Google Workspace connector lets a Project reference Drive docs that stay synced to the live version rather than a stale upload. Put the rules doc and ledger in Drive once, and both camps read the same living copy — no manual re-uploads on either side. (Connector availability varies by plan — check yours; verified July 2026, same click-through caveat as Appendix A.)

Start today: ① One shared ledger + rules doc where both camps can reach it. ② Load the same rules page into each tool per A/B. ③ One weekly review covering claims from every tool.

Appendix D: The ceiling — what the fully-automated version looks like

I run this pattern at rung 4, wired into a content business that publishes across two brands. Here’s what it looks like when the carrying is fully automated — real logs, not a diagram.

Every content-production run starts by loading the house rules from a config file. One run last week opened with this line in its log:

house-rules loaded (3 rules)

During that run I made three corrections at review gates — the kind of small course-corrections you make dozens of times a week and lose. At the end, the system surfaced all three as proposed claims. I approved them in about a minute. The run closed with:

rules-harvested (3 approved)

The very next run opened with:

house-rules loaded (6 rules)

Three rules to six, in one run, with nobody pasting anything forward. The same week, a second brand’s rules file went from zero to two — a cold start, compounding from its first review. And when a later run taught nothing new, the harvest stayed silent: no ritual theater, no approval fatigue. The system asks only when there’s something to ask.

Two details worth stealing even at the floor:

• Every rule carries its provenance — the date and the specific run that taught it. A rulebook where every line traces to a real incident stays trusted; one full of aspirational policy gets ignored.

• The approval gate never auto-approves — even at full automation, every rule passed through a human. That’s rung 4’s entire difference from “let the AI manage its own memory,” and it’s why the file compounds signal instead of noise.

The machinery under this — config files, injected prompts, review agents — is the least important part. It executes the same three moves your spreadsheet does.

If you want help wiring it into your business

The pattern above works standalone — that’s the point, and you don’t need me to run it.

What businesses bring me in for is the part that isn’t in a document: deciding the tag taxonomy that matches how your business actually runs, setting the proposal bar so the ritual stays at ten minutes, wiring the loop into your actual sales and ops processes (not beside them), and knowing which rung of the ladder your team is ready for.

The simple self-test: if three or more people in your business use AI weekly and there’s no shared rules page they all load, you’re paying the leak right now — and a single working session usually fixes it. The first engagement is concrete: we leave the call with your ledger seeded, your tag taxonomy set, your rules page loaded into every seat’s tools, and the weekly ritual on the right person’s calendar. Not a strategy deck — a running loop.

I work in a few shapes, from a single two-hour strategy call to an embedded fractional role. Tell me what you’re working on: david [at] saivvi.com.

Quick start — this week

• ☐ Create the ledger (a Google Sheet, six columns: date · source · type · what we learned · tag · state)

• ☐ Seed it — twenty minutes: your last three AI corrections, the three things you tell every new hire, the one mistake you keep almost making (6–8 proposed claims, so the first review is real)

• ☐ Create the house-rules page (one doc; it starts empty — rules enter only through the weekly review)

• ☐ Load the rules page into each AI tool’s persistent instructions (Appendix A/B/C for your stack)

• ☐ Tell the team the proposing rule: learned something that should change how we work? Thirty seconds, one ledger row, type = claim

• ☐ Calendar the ten-minute weekly review — owner or named delegate, three verbs: approve, edit, reject

• ☐ First review: expect to reject half. That’s the bar working, not failing

You’re already following the build — welcome. More as it compounds.