Phase 1 · ChatGPT · Level 2 · Practitioner
Projects: a workspace per job
By the end, you'll be able to…
- Create a Project with its own instructions and files, and add chats to it
- Use project files so every chat in the Project can draw on the same material
- Keep project memory separate from your main-chat memory, and know why that matters
Why it matters
Once you use ChatGPT for real work, a single stream of chats gets messy: the client proposal, the team rota and the policy rewrite all jumbled together. Projects give each piece of work its own room: its own instructions, its own files, its own memory. It's the difference between a tidy desk per job and one enormous pile.
What a Project is
A Project is a folder for related chats that also carries its own settings. Instead of loose conversations scattered down your history, you group everything about one piece of work (say, "Fernway Q3 launch") into a Project, and it gives you three things the loose chats don't have:
- Project instructions: a brief, like custom instructions, but scoped to this work only. "This Project is about our Q3 product launch. Audience is the senior team. Keep everything concise and UK English."
- Project files: documents you upload once to the Project, which every chat inside it can then read. Upload the brief, the budget and the timeline once, and each new conversation already has them.
- Project memory: anything ChatGPT remembers within the Project stays inside it, kept apart from your general memory and your other Projects.
You'll find Projects in the left sidebar, usually with a New project button near the top. Create one, name it, and you get an empty workspace. Start chats inside it the same way you always do; they just live in this room now, sharing its instructions and files.
Project instructions and files
Open your Project and you'll see a place to add instructions and to attach files. Both apply to every chat you start inside the Project, which is the whole point: you set the context once, at the Project level, rather than re-explaining it in each conversation.
Think about what belongs at which level. Your general custom instructions (from the last lesson) describe you and your house style everywhere. Your Project instructions describe this specific job: its audience, its goal, its constraints. They stack: a chat in the Project gets both.
This Project is Fernway's Q3 product launch. Goal: coordinate the launch and produce clear internal comms. Audience for anything I ask you to write: the senior leadership team, who are busy and non-technical. Always use UK English and keep drafts concise. The launch brief, timeline and budget are attached as project files; treat them as the source of truth, and if I ask something they don't cover, say so rather than inventing it.
Why this works: Scoping the brief to one job (its goal, audience and materials) means every chat in the Project starts oriented, without you pasting the background each time.
For files, upload the durable reference material for this work (the brief, the policy, the data) to the Project itself, not to a single chat. Then any new conversation can draw on them. This is useful: you can open a fresh chat weeks later, ask "what did the brief say the launch date was?", and it answers from the file without you re-attaching anything.
Using the launch brief and timeline in this Project, draft a five-line status update for the senior team: where we are against the timeline, the one thing that's slipping, and what I need from them this week. Quote the relevant dates from the brief so I can check them.
Why this works: Because the file lives at the Project level, a brand-new chat can already answer from it: you ask the question, not re-upload the document.
Project memory versus main-chat memory
This is the part worth slowing down on, because it's the real reason Projects are more than tidy folders.
Your general Memory, the store from the last lesson, follows you across ordinary chats. Projects handle memory differently: what ChatGPT learns and remembers inside a Project is generally kept within that Project, and your main memory doesn't leak in either. In practice, a Project is a compartment. The launch details you build up in the Q3 Project don't start colouring your everyday chats, and a personal fact from an ordinary chat doesn't wander into the client-facing Project.
Why does that matter at work? Two reasons.
First, cleanliness of context. If everything shared one memory, a stray detail from your holiday-planning chat could subtly influence a formal launch email. Compartments stop that bleed, so each piece of work stays on-topic.
Second, and most usefully, separation of sensitive contexts. You might run one Project on a sensitive HR matter and another on general marketing. Keeping their memories apart means details from one can't surface in the other. It's the same instinct as not keeping every document in one shared folder.
The controls sit with the Project: you can view and clear a Project's own memory in its settings, independently of your general memory. When a piece of work ends, you can delete the whole Project (instructions, files, chats and its memory) in one go, which is a tidy way to make sure a finished job's material and context don't linger.
Within this Project only: what context and files are you working from right now? List the project files you can see and summarise what you understand this Project to be about, so I can confirm you're not pulling in anything from my other chats.
Why this works: Asking inside the Project confirms it's drawing on the right compartment (the project files and project context) and not something from your general chats.
Try it now
Common mistakes
- Putting everything in one Project. A Project is per job, not per person. Ten unrelated tasks in one "Work" Project just recreates the mess. Make a Project when a piece of work has its own materials and audience.
- Uploading a file to a single chat when it belongs to the Project. Attach durable reference material at the Project level so every chat can use it; attach one-off files to the individual chat.
- Expecting main memory inside a Project. Projects deliberately compartmentalise memory. Don't assume a Project knows a preference you only ever set in ordinary chats; put it in the project instructions.
- Trusting a file-based answer without checking the file (over-trust). "The brief says the launch is 3 September" feels authoritative because it came from your document, but ChatGPT can still misread a date or blend two figures. Have it quote the line, and glance at the source for anything that matters. A Project makes the material handy; it doesn't make the reading infallible.
Keeping current
Projects are a newer feature and their capabilities (file limits, how memory is scoped, what's shareable) are still evolving. For the current details, see OpenAI's Projects in ChatGPT help article and the ChatGPT release notes. Accurate as of 13 July 2026.