---
title: "How to get AI to remember context"
url: https://howtogetaito.com/remember/context/
published: 2026-09-16
updated: 2026-09-16
author: "Jack Stovell"
author_profile: https://i.hilyt.it/jack
publisher: "Adapt Progress Evolve"
summary: "Standing instructions the assistant reads every chat, a project per recurring job, and the one plain-text file a coding assistant checks before it touches your code: three layers that stop you re-explaining yourself."
tools: ["ChatGPT","Claude","Gemini","Claude Code","Cursor","GitHub Copilot"]
language: en-GB
---

# How to get AI to remember context

> Standing instructions the assistant reads every chat, a project per recurring job, and the one plain-text file a coding assistant checks before it touches your code: three layers that stop you re-explaining yourself.

Published 2026-09-16 · Last updated 2026-09-16 · By Jack Stovell (https://i.hilyt.it/jack) · Canonical page: https://howtogetaito.com/remember/context/

## What you'll be able to do

Right now you're probably doing the thing where you paste your whole project brief into the chat box again, for the third time this week, because the assistant forgot everything the second you closed the tab. That's normal. It's also fixable.

By the end of this you'll have set up standing instructions the AI actually reads every time, a project space for the recurring stuff you work on, and (if you write code) a file your coding assistant checks before it touches anything. You won't be re-explaining who you are or what your codebase does every single morning. That's the whole point.

## Before you start

Here's the bit nobody tells you clearly enough: most AI chat is stateless. Every new conversation starts from nothing. The assistant doesn't know your name, your job, your codebase, or the fact you told it yesterday that you hate bullet points. It genuinely forgets, unless something is set up to stop that happening.

There are two different things people mean when they say "AI memory", and mixing them up is where most confusion starts.

The first is standing instructions: things you write once, yourself, that get fed into every conversation automatically. ChatGPT calls this Custom Instructions. Claude has custom instructions per Project. Gemini has something similar called Saved Info. You write it, you control it, it doesn't change unless you change it.

The second is memory the assistant writes itself, from things you've said in past chats. ChatGPT has a Memory feature that can pick up facts as you talk and store them. Claude has a memory feature on paid plans that works similarly. These are more automatic and a bit more opaque, which is exactly why you need to know how to check and control them.

Both are useful. Neither is magic. And both depend on settings that genuinely do change between updates, so check your own account rather than trusting anything you read here as gospel forever.

## Get set up

Think of this as three layers, going from manual to automatic to embedded.

**Layer one: custom instructions.** This is the slowest but most reliable layer. In ChatGPT it lives under Settings, then Personalization. You write a short "about me" and a short "how I want you to answer", and it gets included, invisibly, in every new chat. Claude's version is per Project rather than global, which actually makes it more useful if you work on more than one thing. Gemini's Saved Info does roughly the same job. None of these require the AI to "remember" anything in the clever sense; you're just handing it a cheat sheet at the start of every conversation.

**Layer two: Projects.** This is the middle ground and honestly the one most people skip past too quickly. ChatGPT Projects and Claude Projects let you bundle files and instructions together, and everything inside that project sees them, every time, without you copying anything in. Gemini's version is called Gems, saved custom assistants built around a task. The trick is to make one project per recurring job rather than one giant project for everything. My business. My book. My job hunt. Three separate boxes, not one overflowing drawer.

**Layer three: the file your coding assistant reads.** If you write code, this is the one that actually matters most. Claude Code reads a file called CLAUDE.md, either in your repo root, in sub-folders for more specific rules, or a personal one sitting in `~/.claude/` for things that apply across all your projects. Running `/init` will draft a starting version for you. Typing `#` at the prompt appends a quick note straight into it, which is a nice habit once you're in the swing of things.

Other tools do the same job under different names. Cursor uses Project Rules, stored under `.cursor/rules`. GitHub Copilot reads `.github/copilot-instructions.md`. A few tools, OpenAI Codex among them, read a file called AGENTS.md. Same idea everywhere: a plain text file the assistant reads before it does anything, so it doesn't need you to explain your build process for the fortieth time. Check the docs for whichever tool you're actually using, because the exact filename and folder do matter.

What goes in that file matters as much as the fact it exists. Put in how to run and test the project, any conventions that aren't obvious just from reading the code, a clear list of things it must never do, and where the important stuff lives. Leave out secrets, long rambling essays, and anything that's going to be different next week. Every line in that file gets read at the start of every session, so every line costs you something, even if it's small.

## Try it yourself

Start with custom instructions. Here's a block you can adapt and drop straight into ChatGPT's Custom Instructions or Claude's Project instructions:

```
About me:
I'm a [your job/role], working mainly on [the main thing you do].
I use [tools/languages/software you actually use].
I'm currently focused on [current project or goal].

How I want you to answer:
Keep answers short unless I ask for detail.
Don't add caveats I haven't asked for.
Use UK English.
If you're not sure about something, say so rather than guessing.
```

Once that's set, it's worth checking what the assistant thinks it knows about you, especially if you're relying on the automatic memory feature rather than instructions you wrote yourself. Try this:

```
Summarise what you remember about me and what you'd like to confirm.
```

This does two things. It shows you what's actually stored, and it flags anything wrong before it quietly shapes every future answer. If something's off, or something's just gone stale, you can correct it directly:

```
Forget that I mentioned working on [old project]. That's finished now.
I'm currently working on [new project] instead.
```

Now the coding side. If you're using Claude Code, running `/init` in your repo will generate a starting CLAUDE.md for you, but it's worth knowing what a good one looks like even before that. Here's a starter template you can paste in and adjust:

```
# Project notes

## Run and test
- Install: npm install
- Run locally: npm run dev
- Run tests: npm test

## Conventions
- Components go in /src/components, one file per component.
- We use TypeScript, not plain JS, for anything new.
- Commit messages: short, present tense, no full stop at the end.

## Never do
- Never touch the /legacy folder without asking first.
- Never commit .env files.
- Never rewrite existing tests without flagging it.

## Where to look first
- Main app logic: /src/app
- Config: /config
- Database schema: /db/schema.sql
```

Keep it short. Add to it as you go rather than trying to write the perfect version on day one. My own set-up is a CLAUDE.md of operating rules, plus a separate folder of small memory files, each one holding a single fact, with a one-line index that loads every session. That way the assistant knows what's already been decided without re-reading a full history every time. You don't need anything that elaborate to start, but it's worth knowing where this can go once the basic version is working.

## Check the result

The test is simple: start a new conversation and see if the assistant behaves like it already knows you.

For custom instructions, open a fresh chat and ask something ordinary, a question with no context attached, and check whether the tone and assumptions match what you told it in your "how I want you to answer" section. If you said keep it short and it gives you four paragraphs, something's not being read.

For memory, ask the summarise prompt again, in a new session, a few days after you first set things up. Does it mention something you told it recently, without you repeating it? That's the feature working.

For Projects, open a new chat inside the project (not a chat outside it) and ask a question that only makes sense if it's read the files you uploaded. If it answers correctly without you re-explaining, you're set up properly.

For CLAUDE.md, start a fresh session in your repo and ask the assistant how to run the tests. If it gets the exact command right without you telling it, the file is being read. If it guesses, something's wrong with the location or the file isn't being picked up at all.

## If it doesn't work

First, check the setting hasn't quietly been switched off somewhere. ChatGPT's Memory can be turned off entirely under Settings, then Personalization, then Manage memories, and individual entries can be deleted one at a time from there too. Using "Temporary chat" skips memory completely for that conversation, which is worth knowing if you ever want a one-off chat that leaves no trace. Claude's memory setting, where available, can be viewed and switched off in a similar way. If nothing seems to be sticking, that's the first place to look.

Second, and more important: never put anything sensitive into custom instructions or memory. No passwords, no API keys, no client data, nobody else's personal details. These systems are built to persist, which is exactly the point, but that also means anything you put in there is designed to come back later, possibly in a context you didn't expect. If you wouldn't want it recalled in six months, don't type it in now.

It's also worth reviewing what's actually stored every so often, the same way you'd occasionally clear out your browser history. Settings change, memory features get updated, and what felt fine to store a year ago might not feel fine now. If in doubt, turn it off for that particular thing and move on.

## Keep exploring

Once your assistant remembers who you are, the next useful step is teaching it to update its own notes as things change, which is covered in "How to get AI to update itself". If you write code, it's worth going deeper on what actually belongs in that project file and how to structure a bigger codebase for it, in "How to get AI to understand my code". And if the tone of the answers still doesn't sound like you, even with memory working, "How to get AI to sound like me" covers that separately, because memory and voice are not quite the same problem.

## Sources and review notes

https://help.openai.com/en/articles/8590148-memory-faq
https://support.claude.com/en/articles/9517075-what-are-projects
https://claude.com/blog/memory
https://support.google.com/gemini/answer/15235603
https://code.claude.com/docs/en/memory
https://cursor.com/docs/rules
https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/add-custom-instructions/add-repository-instructions
https://agents.md/

Review date: 2026-09-16