- In short
- A Claude Project bundles three persistent parts: standing instructions that define what Claude should consistently know and do inside the Project, a knowledge base of reference documents uploaded once and reused across every conversation, and its own conversation history separate from the user's general chat list. Every new conversation started inside the Project begins already primed with its instructions and knowledge base.
What a Project actually holds
The value of a Project is that it remembers, but to use it well you need to know exactly what it remembers. The CCAO-F exam treats this at the understand level: a Project is not one undifferentiated blob of saved context but a bundle of three distinct, persistent parts. Knowing what each part does, and where each kind of information belongs, is what separates a Project that quietly saves time from one that is set up wrong and disappoints.
The three parts are standing instructions, a knowledge base, and the Project's own conversation history. Together they solve the most common productivity drain in AI-assisted work: re-explaining the same background at the start of every session. You set the context once, and every conversation that follows begins with it already in place. This knowledge point builds directly on the recognition that a Project is one of the four entry points.
- Project anatomy
- The three persistent parts of a Claude Project: standing instructions (what Claude should consistently know and do inside the Project), a knowledge base (reference documents uploaded once and reused across every conversation), and the Project's own conversation history (a conversation list separate from the user's general chat history). Every new conversation in the Project starts primed with the first two.
Standing instructions: the persistent brief
Standing instructions define what Claude should consistently know and do inside that Project. They are the persistent brief -- the role, the tone, the constraints, the format rules that apply to everything done in the space. The distinction the exam cares about is that standing instructions are not a one-time message typed into a single chat. A message you type into a lone Chat applies only to that conversation; standing instructions apply automatically to every conversation you ever start inside the Project.
That difference is what makes the setup pay off. Instead of re-typing the escalation thresholds, the house style, or the reporting rules each session, you write them once into the Project's instructions and they are silently present every time. The instructions describe behaviour and knowledge that should hold constantly; the knowledge base holds the reference material that behaviour draws on.
Knowledge base and conversation history
The knowledge base holds reference documents -- policies, prior reports, background files -- uploaded once and reused across every conversation in the Project. The trap the exam probes is the belief that these files must be re-attached in each new conversation. They do not. Upload once, and every conversation in the Project can draw on them without re-uploading. That single fact is most of why a Project saves time on recurring work.
The third part is conversation history. A Project keeps its own conversation list, distinct from your general chat history, so the work done inside a workstream stays grouped with that workstream. This is also where a subtle boundary lives: conversations in a Project share its instructions and knowledge base, but they do not automatically share each other's context. That boundary is important enough to have its own knowledge point in conversation isolation.
What the CCAO-F exam trips candidates on
The exam tests two misunderstandings. The first is believing uploaded knowledge-base files must be re-attached in every new conversation inside the Project. The credited answer is that files live in the Project once and are available everywhere in it -- re-attaching is exactly the manual work a Project exists to remove.
The second is confusing a Project's standing instructions with a one-time message typed into a single chat. A one-time chat message dies with that conversation; standing instructions persist across every conversation in the Project. A question may describe someone re-typing the same brief each session and ask what they should have done -- the answer is to move that brief into standing instructions rather than keep pasting it.
Worked example
An analyst sets up a Project for a monthly client report. She pastes the client's background and format rules into the first conversation, uploads last month's report, and gets a good result. Next month she opens a new conversation in the same Project, re-pastes the background, and re-uploads the file. What did she misunderstand?
She treated the Project as if it were plain Chat with a folder attached, and in doing so paid the setup cost twice. Two of the three Project parts were meant to spare her exactly this.
The client background and format rules should have gone into the Project's standing instructions, not been pasted into a single conversation. Standing instructions apply to every conversation in the Project automatically, so the second month's conversation would have carried them without a word retyped. Pasting them into one chat made them local to that chat and invisible to the next.
Last month's report should have gone into the knowledge base, where it is uploaded once and available to every conversation in the Project. Re-uploading it into the new conversation was unnecessary; the Project already could have surfaced it. The corrected setup writes the brief into standing instructions and the reference file into the knowledge base once, after which each month's conversation starts fully primed and she only pastes the new month's data.
Common misreadings to avoid
Misconception
Knowledge-base files have to be re-attached in each new conversation inside a Project.
What's actually true
Misconception
Standing instructions are the same as a message you type into a chat.
What's actually true
How this shows up on the exam
Questions describe how someone has configured or is using a Project and ask what belongs where, or point out redundant re-setup and ask for the fix. Anchor on the three parts: constant behaviour and knowledge go to standing instructions, reusable reference files go to the knowledge base, and the conversation list belongs to the Project rather than your general history.
This knowledge point unlocks the project worth-building test, which decides when building this bundle is justified, and conversation isolation, which explains the one thing a Project does not automatically share. It also connects to memory persistence and curation, since durable facts can be persisted alongside the Project's knowledge base.
A user opens a fresh conversation inside an existing Project and re-uploads the same reference documents she used last week, then re-types the same role and format brief. Which correction reflects how Projects actually work?
People also ask
What does a Claude Project contain?
Do I need to re-upload knowledge base files each session?
What are standing instructions in a Claude Project?
Watch and learn
Official Anthropic Academy lessons first, then hand-picked walkthroughs. Videos load only when you press play.
No videos curated for this concept yet
We are still curating the best official and community videos for this topic.
Official prep for this domain
Anthropic's own free prep module for this part of the syllabus, on the official prep course. Free with an Anthropic Academy sign-in.
References & primary sources
Master this concept with Archie
Practice it inside an adaptive study session. Archie, your Socratic AI tutor, tracks your mastery with Bayesian Knowledge Tracing and schedules the perfect next review.