TL;DR
A ChatGPT Project binds files, custom instructions, and chats into one workspace, and since the 2026 update it also carries project memory that references earlier chats inside the same Project. That memory is selective, not total: ChatGPT keeps “memory logs” of what it judges important, so for anything you cannot afford to lose (decisions, the live spec), you still keep a written decisions.md as the source of truth. Treat a Project as a discipline, not a folder. File limits as of June 2026: 5 files on Free, 25 on Go/Plus, 40 on Pro/Business/Enterprise, 512 MB per file.
What this tutorial solves
Most long ChatGPT tasks lose the thread after a few sessions because each chat used to start fresh, so you re-pasted the same role, files, and tone notes every Tuesday. Projects fix the re-pasting: instructions and files apply to every chat in the Project, and project memory now lets a new chat reference what earlier chats decided. This guide is for the multi-week author of a thesis, a launch plan, an ongoing audit, or any task that spans more chats than your sidebar can remember.
Who this is for
- People who paste “you are a senior PM helping me launch X, voice is direct…” into five chats a week.
- Anyone juggling a thesis, grant application, launch plan, audit, or product spec across many sessions.
- Writers and analysts whose recurring tasks share 80% of their context but differ in the last 20% of the goal.
What changed in 2026 (read this first)
If you last used Projects in 2025, three things are different and they change how you should work:
- Projects are no longer Plus-only. Free accounts get Projects with a 5-file cap; the feature is broadly available across Free, Go, Plus, and Pro.
- Project memory is built in. For Plus and Pro, a chat can reference earlier chats and files in the same Project. It does not read your whole history — it stores selected snippets it judges important. So memory helps, but it is not a substitute for a written record.
- Project sharing went general (rolled out broadly in late 2025). You can invite collaborators to a Project; everyone sees the same files, instructions, and chats, and shared Projects use project-only memory so context stays contained.
That last point matters for the old advice “you can’t share a Project.” You now can.
| Plan (June 2026) | Price/mo | Files per Project | Projects access | Notes |
|---|---|---|---|---|
| Free | $0 | 5 | Yes | GPT-5.5 with tight limits; US Free shows ads |
| Go | $8 | 25 | Yes | Same Project caps as Plus |
| Plus | $20 | 25 | Yes | Project memory + reference-past-chats |
| Pro | $100 / $200 | 40 | Yes | Higher tool limits; full 1M context only on $200 |
| Business / Enterprise | per seat | 40 | Yes | Admin controls, shared Projects |
Every file is capped at 512 MB, and text files at roughly 2M tokens each, as of June 2026.
When to reach for it (and when not to)
Use a Project when the same context — files, role, tone, goals — shows up in chat after chat and your current workaround is copy-pasting from a saved doc. Skip it for one-off questions, exploratory brainstorming, or anything that fits in a single message. Projects add real overhead (setup, file pruning, instruction maintenance) that does not pay back on short jobs. If you only need it twice, just paste.
Before you start
- Pick the outcome, not the topic. “Q3 launch plan” works; “ChatGPT for marketing” does not — it is too broad to give the model success criteria.
- Draft your Project Instructions in a real editor first. You will iterate on them more than you expect, and the in-app field has no version history.
- Decide which 3-5 files are your daily references. With a hard cap of 25 files on Plus, every slot should earn its place. Everything else stays in local notes and gets uploaded only when needed.
- Plan a chat-naming convention up front.
2026-05-22-press-release-draftbeats “New chat” five weeks later, and it makes project memory easier to navigate.
Step by step
- One Project per long task. Name it after the outcome (“Q3 launch plan”), not the topic (“marketing stuff”).
- Write Project Instructions: role, voice, success criteria, what to ignore. Keep them tight — recall on instructions drops once they sprawl past a few hundred words, so aim well under 1000.
- Upload only your 3-5 daily-reference files. Old drafts and tangents stay out. Replace old versions, do not stack them — with relevance retrieval, ten near-duplicate PRDs make the model pick a random one.
- Start each chat by stating the sub-goal: “Today I want to draft the press release intro.” This anchors the model and gives you a searchable chat name later.
- Maintain a
decisions.mdyou re-upload after each major call. Project memory will recall some of it, but the file is the part you can trust completely. The diff over time is itself documentation. - Every two weeks, prune Project files: remove what is stale, replace with the newer source-of-truth version, and date-stamp filenames so you always know what is current.
A real Project setup
Project name: Q3 product launch
Instructions:
- Role: senior PM helping me run a Q3 SaaS launch.
- Voice: direct, no hedging, no marketing fluff.
- Success: launch on Aug 15 with 5 press hits and a working demo.
- Ignore: anything about Q4 — that is a separate project.
Files (4 of 25 slots used):
- prd-2026-05-22.md (the live PRD)
- target-press-list.md (15 outlets)
- decisions.md (running list of trade-offs we settled)
- voice-samples.md (2 launch posts I want to write like)How project memory actually behaves
This is the part most guides get wrong. Project memory is real but partial:
- A new chat in the Project can reference earlier chats and uploaded files (Plus/Pro). You no longer have to re-explain the basics every time.
- It does not replay your full history. ChatGPT stores selective memory logs — the snippets it thinks matter — so a decision you made in passing three weeks ago may not survive.
- It is scoped. Project chats cannot pull from your general ChatGPT memory or another Project, and nothing leaks out either. Shared Projects force project-only memory.
The practical rule: let project memory handle the convenience (tone, ongoing context) and let decisions.md handle the things that must be exact (final choices, the live spec, the press list). Memory for recall, the file for truth.
Quality check
- After three weeks, open a fresh chat in the Project and ask “summarize what we have decided.” If it misses something important, that decision was never written into
decisions.md— fix the file, not the chat. - Spot-check whether Project Instructions are actually being followed. If a chat ignored “no hedging,” the instructions are too long or self-contradictory. Restate the key constraint in the chat.
- Audit the file list monthly. If you cannot justify why a file is still in one of your slots, delete it.
Reusing the workflow
- For recurring task types (every launch, every audit), keep an “Instructions template” file. New Project = duplicate template + adjust three fields.
- The
decisions.mdpattern is the highest-leverage habit. It works in every Project you will ever build. - For a grant-writing Project: Instructions describe tone and funder; files include the call-for-proposals, last year’s funded sample, your CV, and
decisions.md; each chat handles one section. For Projects centered on web-grounded answers, pair this with a ChatGPT web search workflow so source-grounding lives next to your decisions file. OpenAI’s own Projects help page is the canonical reference for current limits.
Common mistakes
- Treating Projects like folders — dumping every file in and never pruning. On Plus you have 25 slots, and relevance retrieval degrades long before you hit them.
- Trusting project memory for exact facts. It stores snippets, not transcripts. The final wording of a decision belongs in a file.
- Writing 5000-word Project Instructions that ChatGPT then ignores. Recall on instructions drops sharply once they sprawl; keep them well under 1000 words.
- Forgetting that Instructions apply to every chat in the Project, including unrelated ones. Do not ask cooking questions in your launch Project.
- Stacking 10 versions of the same PRD because deleting feels scary. The model will pick a random one.
- Using one Project for two distinct outcomes (launch + post-launch retention). The tone and audience differ; they need separate Projects.
Advanced tips
- Pin the 2-3 chats that capture key decisions; treat them as your hand-curated memory layer on top of automatic project memory.
- Use one Project per audience: a “client-facing” Project and an “internal” Project can share files but use different tones in Instructions.
- For technical Projects, drop a
glossary.mdwith internal acronyms — it saves you 20 explanations a week. - For team work, share the Project rather than exporting files. Collaborators see the same instructions and files, and project-only memory keeps the context contained.
FAQ
- Do Project files count against my context window?: Only the relevant chunks are retrieved per message, but heavy file sets still slow responses. Keep it lean — well under your file cap, and under ~500 KB of working text is a sensible rule of thumb even though the hard per-file limit is 512 MB.
- Can I share a Project now?: Yes. Project sharing became broadly available in late 2025 across Free, Go, Plus, and Pro. Invited members see the same files, instructions, and chats, and shared Projects use project-only memory.
- What is the file limit?: As of June 2026, 5 files per Project on Free, 25 on Go/Plus, and 40 on Pro/Business/Enterprise. The practical limit is lower because relevance retrieval degrades with file count.
- Does a Project remember earlier chats by itself?: Yes, for Plus and Pro — project memory references earlier chats and files in the same Project, but it stores selective snippets rather than your full history. Keep a written
decisions.mdfor anything that must be exact. - Do Projects use my account Memory?: It depends on the memory scope you pick. With project-only memory the chat stays contained to the Project; with default memory it can also draw on your broader account memory. Choose project-only when you want a clean boundary.
- Why does it sometimes ignore my Instructions?: Usually because they are too long, contradictory, or the chat’s own context has overridden them. Restate the key constraint directly in the chat.