A marketer asks AI to write her weekly report every Friday. The first week, it reads like a company brochure. The second week, every update is turned into a table. The third week, it describes a partnership still under negotiation as confirmed. Each time she says “no, rewrite it,” and the next week starts from scratch again.

So she wonders whether she should first gather every project document, template, and writing preference into a knowledge base for AI to read. The idea is reasonable, but it usually stalls on how to organize folders, which tags to use, and which note-taking app to choose. The real difficulty lies elsewhere: she still can’t say clearly how she judges that a weekly report is “wrong.”

The more effective starting point is the time AI got it wrong. Instead of building a perfect database in advance, write each correction as a specific rule AI can read next time, and keep only what will change its behavior next time.

A knowledge base adds data; what the report lacks is judgment

A knowledge base addresses what data AI can read. But a weak weekly report usually isn’t missing data; it’s missing judgment. The standards behind “I can tell at a glance this is wrong,” such as never presenting a deal under negotiation as final, not putting progress updates in tables, or leading with the conclusion because the reader is a manager, are rarely spoken aloud and don’t appear in any project document.

These standards surface most easily when AI gets something wrong. When it describes an unsigned partnership as confirmed, you discover you have a rule: “Anything without a signed contract can only be described as in progress.” The mistake forces the judgment out of your head.

Rules have to be specific for AI to follow them

Saying “no, rewrite it” fixes only this one time. Adding one more sentence, turning it into a rule, makes it usable next time. The difference is whether it’s specific enough.

Anthropic’s documentation for Claude Code illustrates this with a direct example: rather than “format code properly,” write “use 2-space indentation.” The documentation also notes that the more specific and concise instructions are, the more consistently AI follows them, and that when two instructions contradict each other, AI may pick one arbitrarily. Another Anthropic engineering article on AI agents makes a similar point: good instructions sit between two extremes, neither brittle rules that hardcode every detail nor vague guidance that assumes AI knows the background.

Applied to the weekly report:

  • “Make it more professional” is too vague. Better: “Start with one sentence stating the most important outcome of the week, then list three to five updates; leave technical details with no decision value out of the main text.”
  • “Don’t make things up” doesn’t help. Better: “Anything without a signed contract or written confirmation from the other party can only be described as ‘in discussion.’”
Advertisement

Keep only what changes next time

More memory isn’t better. Each correction can first be sorted into one of four kinds to decide whether to keep it:

  • Preferences: for example, write in Traditional Chinese, keep manager reports to one page. These affect many outputs and are worth keeping long term.
  • Processes: for example, after drafting the report, check once whether anything “in discussion” was written as final. Worth keeping, ideally as a step AI runs every time.
  • Judgment boundaries: for example, which things can be written directly and which need a person’s confirmation first. These matter most, because they decide how far AI can go.
  • One-off states: for example, where a project stands this week. These shouldn’t go into long-term memory, or by next week they become outdated background.

That’s also why memory needs regular cleanup. Claude Code’s documentation recommends reviewing these instructions periodically to remove outdated or conflicting ones. ChatGPT’s memory feature also lets users view and delete saved memories, and notes that turning memory off doesn’t automatically delete what’s already stored.

Written rules are reference, not enforcement

Written rules are background for AI to consider, not enforced settings. Claude Code’s documentation says so plainly: these memories are treated as context, not enforced configuration, and anything that must never happen should be blocked by a program-level mechanism rather than a written reminder. At work, that means actions like sending externally, paying, or changing permissions can’t rely on a rule like “remember to ask me first”; AI shouldn’t have permission to do them directly at all.

This method also takes a while to show results. One or two corrections won’t make AI suddenly understand you. After a few weeks of accumulating rules and clearing out stale ones, the number of edits you need on the same kind of task drops noticeably.

What you can do today is small: pick the routine task where you most often have to fix AI’s output, and have AI do it once. When it gets something wrong, don’t just say “rewrite it.” Write three more sentences: Where did it go wrong this time? Which rule that I assumed was obvious was missing? Which kind of rule is it, and should it be kept long term? If the background AI remembers may itself be outdated, see Once AI Remembers Your Opinions, It’s More Likely to Agree With You. If what it remembers is data used for action, like an address or account, see AI Remembering Your Address Doesn’t Mean It’s Safe to Ship There Now.

AI handoff card

Ask AI to turn one correction into a reusable rule This prompt asks where AI went wrong this time, helps turn the correction into a specific rule, and judges whether it should be kept long term.

AI just did one of my routine tasks, but the result was wrong. I want to turn this correction into a rule it can use next time, rather than just telling it to rewrite.
The method comes from this article: https://boosterminiclass.com/en/posts/ai-memory-layer-starts-from-routines/
Its view: building AI memory doesn't start with a complete knowledge base. It starts from the time AI got it wrong, by writing the correction as a specific, checkable rule, and keeping only what changes behavior next time (preferences, processes, judgment boundaries), not one-off states. Things that must be prevented need permissions or program-level mechanisms, not just reminders.

Ask me 3 questions first:
1. What is the routine task, how often do I do it, and who reads the output?
2. What was wrong with AI's output this time, and what did I expect?
3. Does the task involve sending externally, paying, changing permissions, or anything else that's hard to take back if done wrong?

Based on my answers, give me:
- One to three specific rules, each written so you could check whether it was followed (avoid phrases like "be more professional" or "be careful");
- Whether each rule is a preference, a process, a judgment boundary, or a one-off state, and whether to keep it long term;
- Which things shouldn't rely on a reminder but should be blocked by permissions or a confirmation step;
- Which rules AI should read before running this task next time.
Don't rewrite the original task output for me. If information is missing, ask me first.

Rules are for AI’s reference. Whether to follow them in the end is up to the person responsible for the work.

Advertisement

Share

Share this mini class

If this lesson helps untangle a work bottleneck, share it with someone deciding how to use AI.

References