When AI starts remembering: decide what it may forget

An AI that remembers the wrong thing can be worse than an AI that remembers nothing.

It sounds helpful. Answers come faster. Then it says "we usually do it this way." The problem is that "usually" might be an old discount rule, a previous principal's decision, a test environment, a customer that is no longer a customer, or one person's preference that should never become the team's default.

That is why GitHub's latest Copilot Memory update is more interesting than it first looks. Yes, it is written for developers. But the signal matters to anyone connecting AI to real work: AI memory needs scope, ownership, and a deletion routine. Otherwise, memory becomes one more place where old information hangs around and quietly shapes new decisions.

In plain English: AI memory is when an AI tool saves preferences, rules, or project facts so you do not need to repeat them in every prompt. That can be useful. But for a small team, memory has to be treated as working material, not magic.

Start with one small task: choose one recurring AI workflow this week and clean up its memory before you let the tool influence real customer replies, school material, proposals, or internal decisions.

Today's signal: GitHub is making AI memory more controllable

On May 26, GitHub announced more controls for Copilot Memory: better guidance when users want to delete a memory, a repository-level off switch, and Copilot CLI commands: /memory on, /memory off, and /memory show. GitHub also says the prompt that stores memory will more clearly show what type of memory is being saved.

The command is not the interesting part. The scope is.

GitHub describes two types of memory:

• Repository-level facts: facts about a specific code project, such as build commands, architecture decisions, or project rules. They belong to the project.
• User-level preferences: personal ways of working and interaction preferences. They belong to the user.

For a small business or school, the same pattern translates neatly:

• Team facts: "We answer support within two business days", "all proposals must include an expiry date", "class lists must never be pasted into external tools".
• Personal preferences: "write shorter emails for me", "answer in Swedish first", "always ask one check question before drafting text".
• Customer- or student-specific facts: "this customer has service plan A", "this course group uses a special structure".

Those three things should not live in the same place. That is the point.

Source: GitHub Changelog: Copilot Memory has more controls for deletion, scope, and the Copilot CLI

Source: GitHub Docs: About GitHub Copilot Memory

Why this matters for small teams

Many AI problems sound like model problems. They are often memory problems.

A hair salon lets AI help with recurring customer questions. After a few weeks, the tool has learned that "drop-in is available on Fridays." Then staffing changes. If that memory remains, AI keeps suggesting Fridays.

A consultant lets AI help draft proposals. The tool remembers that earlier projects used fixed pricing. That may be right for one customer and wrong for the next.

A school uses AI to structure weekly parent updates. The tool remembers a tone that works for general messages but not for a sensitive student matter.

This does not mean AI memory is bad. The opposite is true. Good memory saves time. It makes answers more consistent, reduces repetitive prompting, and helps new colleagues follow the same routine.

But memory has to answer three questions:

• Who owns this? A person, a team, a customer, a project, or the whole organization?
• How long is it valid? Until further notice, only during the campaign, for this term, or until the next price list?
• How do we delete or update it? Who is allowed to change it, and where do we check what AI thinks it knows?

Without those answers, AI memory is just a faster route to old mistakes.

Run a 35-minute memory cleanup

This is the practical routine. It works whether you use ChatGPT, Claude, Gemini, Copilot, Notion AI, or a more specialized tool. Not every tool has the same memory features, but the working habit is the same.

0–5 minutes: choose one real workflow

Pick something you already do with AI. Not the whole organization. Choose one narrow workflow:

• Answers to recurring customer questions
• Weekly parent updates
• Proposal drafts
• Product descriptions
• Meeting notes turned into tasks
• An internal FAQ for new staff

Write one sentence: "AI is used here to help us with X, but a human approves Y."

5–15 minutes: ask what AI thinks it knows

If the tool has memory, ask it to summarize what it remembers about the work. If it does not, ask it to summarize the instructions, files, templates, or chats that shape the workflow.

Sort the result into four piles:

• Keep: stable rules that still apply.
• Update: rules that are almost right but need a date, scope, or owner.
• Delete: old prices, wrong routines, private preferences, test data.
• Move: personal preferences that became team rules by accident, or team rules that should only apply to one project.

15–25 minutes: write a memory card

A memory card is a short instruction that says what AI may use in this workflow. It is not a policy document. You should be able to read it in under a minute.

Use this structure:

• Workflow: what work does this apply to?
• Owner: who is responsible for keeping the memory correct?
• Validity: when should it be reviewed?
• AI may remember: stable rules and preferences.
• AI may not remember: sensitive details, one-off decisions, test data, old prices.
• Human must approve: customer promises, prices, publishing, sends, student or staff matters.
• Log: where do we record important changes?

25–35 minutes: test the next run

Run one test with an anonymized example. Ask AI to use the memory card and show which rules it relied on. The goal is not a perfect answer. The goal is to see whether the tool pulls the right kind of memory.

If AI cannot show the source of a rule, mark it as "unknown source" and have a person check it before the rule becomes standard.

Copy the prompt: review AI memory for one workflow

Paste this into the tool you use. Replace the brackets.

You are helping us review AI memory and instructions for one narrow workflow.

Workflow: [e.g. recurring customer replies / weekly parent update / proposal draft]
Current material: [paste the current instruction, template, chat excerpt, FAQ, or list of rules]
Goal of the workflow: [what AI should help with]
Human must always approve: [e.g. price, customer promise, publishing, send, sensitive matter]

Do this:
1. List what AI seems to assume or remember about the work.
2. Put each point into one of these buckets: keep, update, delete, or move.
3. Explain why each point belongs there.
4. Mark whether each point is a personal preference, team rule, customer/project-specific fact, or unknown source.
5. Suggest a short memory card with owner, validity, rules AI may use, and things AI must not save.
6. Write three check questions a human should answer before we use this in live work.

If something is missing, write "missing". Do not guess.

That last line matters. Good AI memory should not sound confident when the evidence is missing.

Integrate safely without freezing up

When AI only writes text in a chat window, good instructions and human review often go a long way. When AI connects to files, tickets, customer systems, or publishing tools, the frame needs to be a little clearer.

Keep it simple:

• Start with read access where that is enough.
• Use separate scoped API keys for test and production.
• Put keys in environment variables or a secret manager, not in prompts or documents.
• Add approval gates for sends, price changes, invoices, publishing, and customer-data edits.
• Keep a run log: who asked AI to act, what evidence was used, what changed?
• Redact unnecessary personal data in test material.
• Turn memory off for workflows where the information only applies once.

This is Tool Forge in practice: the tool gets the right system access at the right level. Mindset Forge is deciding which rules humans must own. Skill Forge is the habit of cleaning up memory regularly, not only after something has gone wrong.

Good AI memory should feel almost boring

It should not surprise you. It should not invent "how we usually do things." It should help the team avoid writing the same stable instruction twenty times while still being easy to inspect.

A useful rule of thumb: if a new team member should not use a piece of information without onboarding, AI should not use it without scope either.

And when AI says it remembers something, ask where that memory belongs.

Personal. Team. Project. Customer. Temporary.

That answer is often more important than the text AI writes.

FAQ: AI memory for small teams

Do we have to use AI memory? No. Start without it if the work is new, sensitive, or unclear. Add memory only when you have a routine that actually repeats.

What should AI be allowed to remember? Stable preferences, format rules, approved tone, and recurring work rules. Things that will make the work better next week too.

What should AI not remember? One-off decisions, old prices, unnecessary personal data, test data, sensitive student or customer details, and private preferences that accidentally affect the whole team.

How often should we clean it up? For a small team, a quick monthly check is often enough, plus an extra review when prices, staffing, customer promises, course structures, or system permissions change.