Key Takeaways
- Custom instructions apply everywhere but hold only static text you write yourself — they never grow from what you tell ChatGPT day to day.
- Projects group files and context tightly around one specific piece of work, but stay walled off from every other Project and from general chat.
- Memory holds individual durable facts across all your chats, but only reliably for things explicitly saved — not documents, and not process detail.
- None of the three talks to the other two: a Project's files, a memory, and a custom instruction can all exist for the same business and never once inform each other.
- Claude and Gemini split the same three jobs differently — larger Project context windows on Claude, memory on by default on Gemini — but the underlying decision logic is the same regardless of platform.
Halima Osei runs a 7-person podcast production and media agency in Madison. She'd set up custom instructions telling ChatGPT to always flag copyright risk in show notes. She'd also started a Project for one client's rebrand, with the brand guidelines uploaded. And at some point she'd told ChatGPT, in passing, that the agency never publishes an episode without a signed guest release.
Weeks later, drafting show notes for a different client entirely, none of the three showed up — not the copyright flag, not the release-form rule, nothing. Each piece of context was real and correctly set up. None of them were built to reach a chat outside their own lane.
That's the actual relationship between these three features: not competitors, not upgrades of each other, but three different tools for three different scopes. Knowing which one a given piece of information belongs in is most of what makes any of them work.
What Custom Instructions Actually Do (and Don't)
Custom instructions are static text, written once in Settings, applied to every new conversation automatically. OpenAI's documentation sets the limit at 1,500 characters for Free and Go accounts, 5,000 for Plus, Pro, Enterprise, Business, and Education. They're the right home for standing rules that should apply no matter what the conversation is about — Halima's copyright-flag instruction is exactly this kind of thing.
What they don't do: grow, adapt, or hold documents. Custom instructions are exactly what you typed, applied everywhere, until you go back and edit them by hand.
What ChatGPT Projects Actually Do (and Don't)
Projects scope files, chats, and project-specific instructions to one initiative — Halima's client rebrand, with its brand guidelines, belongs here. File limits scale by plan: 5 on Free, 25 on Plus/Go/Edu, 40 on Pro/Business/Enterprise. Every chat inside that Project can draw on the same material without re-uploading it.
What Projects don't do: extend outside their own boundary. The brand guidelines in the rebrand Project have no bearing on a different client's chat, even though both clients belong to the same agency. That isolation is deliberate — it's what keeps a Project's context from getting diluted by unrelated work — but it means Projects were never going to be where Halima's release-form rule lived, since that rule applies to every client, not one.
What Memory Actually Does (and Doesn't)
Memory is for individual facts meant to follow you into any chat, not documents or process detail — which is exactly the category Halima's release-form rule falls into. It splits into two systems with different reliability, covered in full in `ChatGPT Memory Not Working`: saved memories (explicit, durable) and reference chat history (passive, selective by design, and — per OpenAI's own documentation — not guaranteed to keep everything it's ever picked up on).
Mentioning something once in a busy conversation, the way Halima mentioned the release-form rule, is exactly the case reference chat history is least reliable for.
Where People Get the Assignment Wrong
Beyond Halima's specific mix-up, the same misassignment shows up in a few recurring patterns worth naming directly.
Putting a client's ongoing details into custom instructions instead of a Project. It's tempting to add "Client X always wants a two-week follow-up cadence" to custom instructions because it feels important enough to apply everywhere. But that fact is scoped to one client, not every conversation — every other client's chat now carries irrelevant context, and if the agency takes on a second client with a different cadence, the instruction set starts contradicting itself.
Uploading a document to a Project and expecting it to inform general chats. The isolation that makes Projects useful is the same isolation that surprises people the first time they need something from a Project's files in an unrelated chat. It doesn't cross over, by design.
Treating memory as a place for documents. Memory holds facts — short, discrete, expressible in a sentence. A process document, a style guide, a full set of brand guidelines belongs in a Project's files, not typed out as a memory. Trying to force a document into memory either fails outright or produces a garbled, incomplete version of what should have been an upload.
Assuming a fact saved once will stay relevant forever. Halima's agency signs new clients with their own quirks — some want a monthly instead of weekly update cadence, some have their own release-form variants. A memory saved a year ago ("always send the standard release form") can become quietly wrong the moment an exception gets introduced, and nothing in ChatGPT flags that a saved memory might be stale. Facts saved into memory need the same occasional review a written policy would — they don't self-correct when circumstances change.
Duplicating the same fact across all three features "to be safe." It's tempting, once the three-way split becomes clear, to over-correct by putting an important fact into custom instructions, a Project, and memory simultaneously. The problem shows up the first time the fact changes: now there are three places to update, and it's easy to update two and miss the third, which produces a worse version of the original problem — inconsistent context, just spread across more places instead of one.
Which One You Actually Need, by Situation
A rule that should apply to every conversation, regardless of topic — Right tool: Custom instructions
Files, notes, and chats scoped to one client or initiative — Right tool: A Project
One durable fact that should follow you everywhere — Right tool: Memory (saved explicitly)
The same full setup needs to be reused by other people — Right tool: A custom GPT (see `How to Give ChatGPT Context About Your Company` for when that's worth the extra setup)
Most situations map cleanly to one of these. The confusion happens when a piece of information — like Halima's release-form rule — clearly belongs in one category but gets mentioned casually in a chat instead of being deliberately placed there.
A rough test that catches most of these: if the fact should apply no matter who's talking to ChatGPT or what the topic is, it belongs in custom instructions or memory, not a Project. If it only makes sense in the context of one specific client or piece of work, it belongs in a Project, not memory. Halima's rule failed that test in practice, not in principle — it was the right kind of fact for memory, just never deliberately saved there.
How This Compares Across ChatGPT, Claude, and Gemini
The three-way split isn't unique to ChatGPT, though the specifics differ enough to matter if a business is standardizing on a particular platform.
Claude's Projects work on the same principle as ChatGPT's — a scoped workspace with its own files and instructions — but with a much larger effective context window per project, roughly 200,000 tokens, which Anthropic describes as comparable to a 500-page book.
Claude's memory, rolled out to every user (free and paid) in March 2026 and unified across Claude's chat and Claude Cowork products just this week, works more like ChatGPT's reference chat history than its explicit saved memories. It synthesizes a running summary rather than storing discrete facts you deliberately chose to save, which means it inherits the same "quietly updated, quietly dropped" behavior described above for ChatGPT's passive layer.
Gemini splits things differently again. Its Personal Context feature is the closest equivalent to memory, and it's on by default for eligible personal Google accounts rather than something a user has to switch on — which cuts against ChatGPT's more deliberate, opt-in feeling. It's unavailable entirely on work, school, or supervised accounts, a real consideration for any business planning to move from personal Gemini testing to a company Workspace account.
None of these differences change the underlying decision framework. Whether a fact belongs in a standing instruction, a scoped workspace, or an individual memory is the same question regardless of which platform's settings menu it needs to go into.
There's a practical implication for any agency like Halima's that ends up using more than one AI tool across the team — one person on ChatGPT, another who prefers Claude. The classification logic transfers cleanly: this fact is a standing rule, this one is client-specific, this one is a durable individual fact.
The actual configuration doesn't transfer, though. A custom instruction written for ChatGPT has to be separately re-entered as Claude's equivalent setting, and a memory saved in one tool has no way of appearing in the other. Standardizing the underlying decision across a team is only half the work; someone still has to maintain the same context twice if the team is split across platforms.
What This Looks Like Once the Agency Scales
Halima's mix-up happened at 7 people. The same three features get harder to manage correctly, not easier, as a team grows: more clients means more Projects to keep organized, more staff means more individual accounts each maintaining their own memory, and more standing rules accumulating in custom instructions until the character limit itself becomes a constraint.
A 20-person version of Halima's agency would likely be running into the character ceiling on custom instructions. It would be managing a Project per active client that someone has to remember to archive when the engagement ends, and dealing with memory that's inconsistent from staff member to staff member depending on who set up their account when and what they happened to save explicitly.
None of that is a failure of Halima's setup. It's what happens when three per-account, per-conversation-scoped features get asked to do the job of a shared, organization-wide context layer they were never built to be. The three-way split works cleanly at the scale it was designed for: one person, one account, a manageable number of standing rules and active projects. It strains exactly where a growing business needs it not to.
Why Getting This Right Still Isn't Enough
Set up perfectly — the right fact in the right feature, every time — these three still don't talk to each other. Custom instructions can't see what's in a Project. A Project can't see what's saved in memory. Nothing automatically checks whether a new fact belongs in one, two, or all three.
`Why AI Forgets Your Business` covers why that's structural, not a configuration mistake, and what it actually takes to give a business one shared, current picture instead of three separate, non-communicating ones — closer to what a teammate is built to hold than what any combination of these three features adds up to.
Tired of remembering which ChatGPT feature is supposed to hold which fact? Sign Up for Free — no credit card required, free to start, cancel anytime.