Claude Projects: Context That Sticks Around
A single Claude conversation remembers everything inside it, but nothing outside it. If you've been re-pasting the same client background, team structure, or project summary at the start of every new chat about the same ongoing work, that's not a habit problem. It's a sign the work has outgrown a single conversation.
Tip
A Project is a space where the files and instructions you set up once stay available to every chat you start inside it, not just the one conversation you happened to type them into.
A single chat remembers one conversation. A Project remembers the work.
Why the same context keeps reappearing
A plain chat's memory is scoped to that one thread. That's fine for a task with a clear beginning and end, but it breaks down the moment you're returning to related work across many separate conversations over days or weeks: a recurring client, a multi-part initiative, anything where the background doesn't change but the specific task each time does.
Without a shared space, every new chat starts from zero, and you end up doing the same setup work repeatedly just to get Claude back to where the last conversation left off.
Before: start a new chat for each task in an ongoing initiative, re-explain the background, the team, and the goal every single time.
After: set up a Project once with that background, then start each new task already caught up.
Chat, Project, or custom instructions
Claude gives you three places to put context, and they solve different problems.
| Container | Context lasts | Best for |
|---|---|---|
| A single chat | Only that conversation | A task with a clear start and end |
| Custom instructions | Every chat you ever have | Standing preferences: your role, tone, how you like answers formatted |
| A Project | Every chat inside that Project | Background for one body of ongoing work: a client, an initiative, a codebase |
Custom instructions are for how you always want Claude to behave. A Project is for what Claude needs to know about one specific thread of work. If the background only matters for a handful of related tasks this month, a single chat you keep returning to is often simpler than either.
A process for setting up a Project worth using
- 1
Notice when a task is really part of something ongoing
If you can picture yourself needing this same background again next week for a related but different task, that's the signal a Project is worth the setup, not a one-off chat.
- 2
Add the background that doesn't change task to task
Include what stays constant: who the work is for, the goal, standing terminology, relevant documents. Leave out anything specific to a single request, that still belongs in the individual chat.
- 3
Start each new task as a new chat inside the Project
Each chat still works like a normal conversation, but it opens already knowing the background instead of starting cold.
- 4
Update the shared context when the underlying work changes
A Project's usefulness depends on the background actually staying current. If a goal or a key detail changes, update it there once rather than letting every new chat inherit stale information.
| Belongs in the Project | Belongs in the individual chat |
|---|---|
| Who the work is for and the overall goal | The specific ask for this one task |
| Reference documents that stay relevant | A file only this task needs |
| Standing terminology, names, and constraints | This week's numbers or deadline |
| How you want output structured for this work | One-off instructions for a single answer |
I'm setting up a space for an ongoing vendor negotiation. Help me draft a short background brief covering who's involved, the goal, and the key terms we've already agreed on, so I can reuse it across every conversation about this deal.
”One brief like that, added to a Project's knowledge once, then feeds every conversation you start inside it: drafting this week's update, comparing a new counteroffer, briefing a colleague joining the deal. None of them start by re-explaining the deal, because the Project already holds it.
Inside Claude Tutorial
Persistent context is useful well beyond this one example.
Setting up a space that remembers your background so you don't have to repeat it is one of many reusable Claude habits the app teaches through short lessons and real practice.
Three Projects worth setting up
The pattern is always the same: stable background, changing tasks. A few that come up often:
- A recurring client or account. Knowledge holds the contract terms, the people involved, past decisions, and how they like to be communicated with. Each chat drafts an update, preps a call, or works through a request, without you re-explaining the relationship.
- A long research or writing project. Knowledge holds your outline, sources, style notes, and what you've already decided. Each chat drafts a section, checks a claim, or reworks a passage against the same plan.
- One codebase. Knowledge holds the architecture notes, conventions, and the parts of the system that matter. Each chat debugs, reviews, or plans a change without a fresh tour of the code every time.
When a Project is overkill
Not every recurring topic deserves its own Project. If the same background only matters for a handful of related tasks over a short window, a single chat you continue is often simpler than setting up and maintaining a separate space.
You'll return to this same background across several separate conversations spread over weeks, not just today
The context is stable enough to be worth writing down once, not changing every time you open a new chat
Re-explaining the background from scratch each time would genuinely cost you real time, not just a sentence or two
Is this ongoing enough to be worth its own space, or would a single conversation I return to over the next two weeks work just as well? Here's what the work actually involves: [describe the task and its expected timeline].
”Setting up a Project is a one-time cost that pays off the second time you'd otherwise have re-explained the same background.
Common mistakes
- One giant Project for everything. Unrelated background bleeds together and every chat gets context it doesn't need. One Project per body of work.
- Loading in documents you'll never reference again. Knowledge is for what stays relevant. A file for a single task belongs in that task's chat.
- Letting the knowledge go stale. A Project that still describes last quarter's goal quietly makes every new chat wrong. Update it the moment the underlying work changes.
- Putting task-specific detail in knowledge. This week's numbers or a one-off instruction inherited by every future chat is noise. Keep those in the individual conversation.
Frequently asked questions
What is a Claude Project?
A Project is a workspace where files and instructions you add once stay available to every chat you start inside it. It's for background that doesn't change task to task, so you stop re-pasting it.
What's the difference between a Project and a normal chat?
A normal chat remembers only itself. A Project remembers across all of its chats. Use a chat for a task with a clear end; use a Project when you'll keep coming back to the same background over weeks.
How is a Claude Project different from a ChatGPT project?
The idea is similar: a folder of chats that share files and instructions. The practical differences are in limits, file handling, and how each model uses that context, so test your own workflow rather than assuming they behave identically.
Do Claude Projects share memory across chats?
They share the knowledge and instructions you set up, not the back-and-forth of individual conversations. Each chat still starts fresh on the task itself, just already aware of the background.
How many files can a Project hold?
There's a limit, and it changes over time along with per-file size caps. Check the current numbers in the app. In practice, a focused set of genuinely relevant documents works better than filling the space to its ceiling.
Do I need a paid plan to use Projects?
Availability by plan changes, so check the current plan pages. The habit this guide teaches, writing background down once and reusing it, is worth building regardless of where you keep it.
Continue reading
- Choosing a New Chat, a Project, or Picking Up Where You Left Off: the full decision framework for which container a given piece of work actually belongs in.
- Building a Reusable Context Brief You Stop Retyping: how to write the background block that goes into a Project's knowledge.
- Organizing Long Claude Conversations: when to start a fresh chat inside a Project instead of continuing a long one.
- What Files Can Claude Read? How to Upload Them: getting the documents you add to a Project into a form Claude can actually use.
- Getting Started with Claude: the reusable-instructions habit this article extends into something persistent instead of pasted in by hand each time.