Custom Instructions and Memory: Persistent Context in ChatGPT

The Problem of Repeated Context

Every new ChatGPT conversation starts completely blank. Without persistent context, you repeat the same setup every time: your role, your stack, your preferences, what you do and don't need explained.

ChatGPT Plus provides two complementary solutions: Custom Instructions (structured persistent prompts) and Memory (dynamic notes ChatGPT maintains about you).

Custom Instructions

Custom Instructions are two persistent text fields that prepend to every conversation. Access them via Settings → Personalization → Custom Instructions.

Field 1: "What would you like ChatGPT to know about you?"

This is your background context. Write it as facts about yourself:

I'm a senior full-stack developer with 8 years of experience.
Primary stack: React 18, TypeScript (strict mode), Node.js,
PostgreSQL, and Supabase.

I build multi-tenant SaaS applications. Current projects are
primarily web dashboards and internal tooling for mid-market companies.

I'm comfortable with advanced TypeScript, database design,
and distributed systems. I don't need basic concepts explained.

Field 2: "How would you like ChatGPT to respond?"

This is your behavioral instructions:

- Skip beginner explanations. Assume senior-level knowledge.
- Be direct. State the answer first, then explain if needed.
- For code: use TypeScript, strict types, no any.
- For code: use my stack (React, Supabase) unless I specify otherwise.
- When reviewing code: list issues by severity (HIGH/MEDIUM/LOW).
- Don't add "Remember to..." or "Note that..." caveats to code responses.
- If something has multiple valid approaches, state your recommendation first,
  then list alternatives.
- Short responses are fine. Don't pad for length.

Custom Instructions are the same across all conversations. They're best for stable, long-term preferences.

Memory

Memory is a dynamic system. ChatGPT can store and retrieve notes about you across sessions. Unlike Custom Instructions (which you write once), Memory updates over time as you use ChatGPT.

How Memory Updates

ChatGPT adds memories automatically when you share persistent information:

"I work at a healthcare startup building a patient portal."
"My team follows the Airbnb TypeScript style guide."
"I always want JSDoc on public functions."

You can also instruct ChatGPT directly:

Remember that I prefer Vitest over Jest for new projects.
Remember that I follow Conventional Commits for commit messages.

Viewing and Managing Memory

Settings → Personalization → Manage Memories

Review this list periodically. Delete outdated entries (technologies you no longer use, projects that ended). ChatGPT draws on all active memories in every conversation — stale memories create noise.

Instructing ChatGPT to Forget

Forget that I work on [project name]. That project is complete.

Or delete entries directly from the memory manager.

A Practical Configuration

Here is a production-ready Custom Instructions setup for a developer:

About You:

Senior software engineer specializing in TypeScript web applications.
Stack: React 18, TypeScript 5 (strict), Node.js 20, PostgreSQL 15,
Supabase, TanStack Query v5, Tailwind CSS.
Role involves full-stack feature development, code review,
and technical design for a SaaS product.
Based in [timezone] — relevant for scheduling questions.

Response Preferences:

Respond like you're pairing with a senior engineer.
Code: TypeScript with strict types. Match my stack unless told otherwise.
Reviews: format as [HIGH/MEDIUM/LOW] Location: Issue (one line each).
Explanations: skip fundamentals, start at intermediate level.
Formatting: use code blocks for all code, markdown for structure.
Length: as short as the task allows. No filler.
For ambiguous requests: make a reasonable assumption and state it,
don't ask a clarifying question unless truly needed.

When to Use Custom Instructions vs. Memory vs. System Prompts in a Conversation

Custom Instructions: Stable, long-term preferences that apply to everything. Your role, stack, communication style.

Memory: Dynamic, project-specific, or evolving information. Current projects, recent decisions, ongoing context.

In-conversation context: Task-specific information that shouldn't affect future conversations. Specific code being reviewed, one-off requirements, session-specific constraints.

Don't put everything in Custom Instructions. They're limited in length and clutter responses if overloaded. Use them for truly universal preferences and let Memory handle the rest.

Key Takeaways

• Custom Instructions are static, universal, and set once — use for stable role and style preferences
• Memory is dynamic and evolves — use for current projects, tech decisions, and ongoing context
• Review Memory periodically and delete stale entries
• In-conversation context is for session-specific information that shouldn't persist
• A well-configured Custom Instructions + Memory setup eliminates most of the repeated setup cost of every new conversation

---

Try It Yourself: Write your Custom Instructions right now. Spend 10 minutes on it. "About you" section: your role, stack, and experience level. Response preferences: output format, depth level, code conventions. Then start a new conversation and ask a technical question. Compare the default response against the instructed one.