+160 XP

The Claude apps and projects: persistent context that remembers

Drop a 200-page company handbook and a one-page style guide into a Claude Project, and every chat inside that Project starts already briefed: Claude answers in your house voice, cites your policies, and never asks you to re-paste the same documents again. That is the whole promise of Projects, and it is the most underused feature in the Claude ecosystem.

This lesson tours the Claude apps, then goes deep on Projects as a persistent-context container. You already understand the context window. The question here is operational: how do you stop manually feeding the same background into every conversation?

The three Claude apps, briefly

Claude ships as three clients that share one account and one set of features:

  • Web (claude.ai) is the canonical surface. Everything lands here first.
  • Desktop (macOS and Windows) adds local MCP servers, so Claude can act on files and apps on your own machine. This is where Claude stops being a chat box and starts touching your environment.
  • Mobile (iOS and Android) is for capture and quick queries: dictate a thought, snap a photo of a whiteboard, continue a Project chat from the train.

They are not three products. A Project you create on web is instantly available on desktop and mobile. The differences are about *reach*. Remote connectors (Google Drive, GitHub, Notion and similar) work on every client. Only desktop can run local MCP servers that reach your filesystem and local apps.

One term to define and move on: a Connector is a plug that lets Claude read from or act on an external system (Google Drive, GitHub, a database) using MCP, the Model Context Protocol. We will treat connectors lightly here and go deep on them in a later lesson. Today's focus is the persistent-context layer that sits *above* any connector.

What a Project actually is

A Project is a workspace that bundles these pieces and applies them to every chat created inside it:

  1. Project knowledge: files and text you upload once (PDFs, docs, spreadsheets, pasted reference text).
  2. Custom instructions: a standing system-level brief that shapes tone, format, and behavior.
  3. The chats themselves: every conversation you start in the Project, kept together.
  4. Project memory (where memory is enabled): a summary Claude builds from your past chats in that Project, kept separate from your other Projects.

The mental model: a normal chat is a blank room. A Project is a room where the briefing is already on the wall before you walk in. You are not re-establishing context each time; you are continuing from a shared baseline.

This is different from pasting your handbook into a single conversation. Paste-and-go context dies when the chat ends. Project knowledge persists across every chat, indefinitely, for everyone with access to the Project (on Team and Enterprise plans, Projects can be shared).

The official reference lives at Anthropic's Projects help docs.

Memory: what Claude picks up on its own

Since late 2025, Claude can remember context from past conversations. You can view and edit what it has stored, and you can switch it off in settings. It also has an incognito mode for chats you want kept out of memory.

The detail that matters for this lesson: memory is scoped per Project. What Claude learns in "Support Desk Assistant" stays there and does not leak into your "Q3 Marketing Copy" Project. That makes Projects the natural boundary for keeping client work, teams or confidential topics apart.

Memory and Project knowledge do different jobs. Knowledge is what you deliberately upload and control. Memory is what Claude infers from how you work (your recurring questions, decisions you made last week). Do not rely on memory for policy. If a rule matters, write it into the instructions or the knowledge panel.

The concrete build: handbook plus style guide

Here is the scenario from the hook, done properly.

You have two assets:

  • company-handbook.pdf: 200 pages of policies, benefits, escalation paths, security rules.
  • style-guide.md: one page on voice (warm, direct, no jargon, British spelling, never promise refunds without manager sign-off).

Step 1: Create the Project. In the web app, open Projects and create one called "Support Desk Assistant."

Step 2: Add the handbook to Project knowledge. Upload company-handbook.pdf into the knowledge panel. Claude indexes it. Now every chat in this Project can reference page 147's escalation policy without you pasting anything.

Step 3: Write custom instructions. This is where most people undercook it. Be specific:

text
You are the internal support assistant for Acme Ltd.

Sources of truth:
- Always ground policy answers in the uploaded company handbook.
- Always follow the uploaded style guide for voice and formatting.

House rules:
- Use British spelling. Warm but direct. No corporate jargon.
- Never promise a refund. For refunds, instruct the user to flag a manager
  and quote handbook section 6.2.
- If the handbook does not cover something, say so plainly and do not guess.
- End policy answers with the handbook section number you used.

Step 4: Test it. Start a new chat in the Project and ask: "A customer wants a refund after 40 days. What do I tell them?"

Claude answers in British spelling, in the warm-but-direct voice, declines to promise the refund, points to section 6.2, and cites the source. You pasted nothing. The next chat, and the chat your colleague starts tomorrow, behave identically.

That repeatability is the point. A Project turns "Claude that happens to know this today" into "Claude that reliably behaves this way every time."

Project knowledge vs. the context window

A fair question: if you drop 200 pages in, does that eat your context window on every message?

Not the way pasting would. When Project knowledge is large, Claude retrieves the relevant chunks rather than stuffing the entire document into every prompt (the same retrieval idea you met at the concept level earlier in the course). When it is small, it can sit fully in context. Either way, you are not manually managing it.

Practical implication: keep Project knowledge *curated*. A tight handbook plus a clean style guide beats dumping forty loosely related PDFs. Retrieval quality drops when the knowledge base is noisy. Treat the knowledge panel like a reference shelf, not an attic.

Styles: voice without rewriting instructions every time

There is overlap worth clarifying. Styles let you save a reusable writing voice (formal, concise, your brand tone) and apply it to any chat with one click, *across* Projects. You can even teach a Style from sample writing.

So when do you use which?

  • Put behavior and rules that are specific to one body of knowledge in the Project's custom instructions (the refund rule above).
  • Put reusable voice you want everywhere into a Style.

In the handbook example, "British spelling, warm, direct" is arguably a Style you reuse across many Projects, while "quote section 6.2 for refunds" belongs in this Project's instructions. Splitting them keeps each Project lean and your voice consistent company-wide.

Where artifacts and skills fit

Two more pieces complete the picture inside the apps.

Artifacts are the standalone outputs Claude generates in a side panel: a document, a working web app, a chart, an interactive tool. Inside your Support Desk Project, you could ask Claude to build an Artifact: a small triage checklist app that encodes the handbook's escalation logic. It renders live, you can iterate on it in the same chat, and it inherits the Project's grounding.

Skills are packaged, reusable capabilities, folders of instructions plus optional scripts and resources that Claude loads when a task needs them. Where a Style shapes voice and Project knowledge supplies facts, a Skill teaches Claude a *procedure*: how to format a quarterly report exactly your way, or how to run a specific document-processing flow. Skills work across the apps, the API, and Claude Code. See the Agent Skills docs for the structure.

The layering is the mental model worth keeping:

  • Project knowledge = what Claude knows.
  • Custom instructions = how Claude behaves *here*.
  • Memory = what Claude has picked up from your past chats in this Project.
  • Styles = how Claude sounds *everywhere*.
  • Skills = procedures Claude can execute.
  • Connectors / MCP = systems Claude can reach.

How to use Claude Projects

Watch on YouTube

Knowledge check

1. What is the core problem that Claude Projects are designed to solve?

2. The lesson uses the metaphor that a normal chat is a 'blank room.' What does a Project correspond to in this metaphor?

3. According to the lesson, what primarily distinguishes the three Claude apps (Web, Desktop, Mobile) from one another?

MULTIPLE CHOICE

4. Select ALL of the things that a Project bundles and applies to every chat created inside it.

Select all the correct answers.

MULTIPLE CHOICE

5. Select ALL statements that correctly describe how the desktop app and connectors work according to the lesson.

Select all the correct answers.

Connectors and GitHub: when a Project needs live data

Static knowledge is enough for a handbook that changes quarterly. But some Projects need *current* data, and that is where Connectors come in.

The apps include a connector directory: switch on Google Drive, Gmail, GitHub, Notion and others, and a chat can read from them in real time on web, desktop or mobile. You can also add custom remote MCP servers. Local MCP servers, which reach files and tools on your own machine, run only in Claude Desktop.

The GitHub integration is the standout for technical teams. Connect a repository and Claude can read your codebase as context. In a Project scoped to one repo, you can ask "where do we validate the refund window?" and Claude reasons over the actual code. This is the bridge to Claude Code, the agent that operates directly on your repo, which gets its own deep lesson later in this path.

The distinction to hold onto: Project knowledge is a snapshot you uploaded. A Connector is a live line to a source. Use knowledge for stable references (the handbook). Use connectors for things that change under you (open tickets, the current branch, this week's spreadsheet).

When to reach for the API instead

Everything above is the app experience: human in the loop, clicking through chats. When you want this *programmatic*, you drop to the Anthropic Messages API, where Project-style persistent context becomes a system prompt plus documents you attach per request.

python
import anthropic

client = anthropic.Anthropic()

with open("style-guide.md") as f:
    style_guide = f.read()

message = client.messages.create(
    model="claude-sonnet-4-5",  # check the models page for the latest name
    max_tokens=1024,
    system=(
        "You are Acme Ltd's support assistant. Follow this style guide "
        f"exactly:\n\n{style_guide}\n\n"
        "Never promise refunds; quote handbook section 6.2 instead."
    ),
    messages=[{
        "role": "user",
        "content": "Customer wants a refund after 40 days. What do I say?",
    }],
)

print(message.content[0].text)

That system block is the API equivalent of a Project's custom instructions, and attaching documents per request mirrors Project knowledge. Nothing persists between API calls unless you send it again (or build your own storage). The app makes this point-and-click and persistent; the API makes it scriptable and embeddable. For agentic workflows, the Claude Agent SDK wraps this same model with tools and loops. Start at the API docs.

Rule of thumb: use Projects when humans are doing the work in a shared, evolving space. Use the API or Agent SDK when software is doing the work at scale.

A few non-obvious habits

  • One Project per job, not per topic. "Support Desk Assistant" and "Q3 Marketing Copy" should be separate Projects with separate instructions (and separate memory). Mixed Projects produce muddy behavior.
  • Version your knowledge. When the handbook updates, replace the file rather than uploading a second copy. Two versions in the knowledge panel guarantees contradictions.
  • Write instructions as rules, not vibes. "Never promise a refund; quote section 6.2" is enforceable. "Be helpful about refunds" is not.
  • Check memory now and then. If Claude has stored something outdated about a Project, edit or delete it.
  • Pin the source-citation rule. Asking Claude to end answers with the section it used turns a confident assistant into an auditable one.

Key Takeaways

  • A Project bundles persistent knowledge, custom instructions, and chats so Claude starts every conversation already briefed. Stop re-pasting context.
  • Memory is scoped per Project, so Projects also work as privacy boundaries. Put rules that matter in instructions, not memory.
  • Layer your tools by job: knowledge (facts), custom instructions (behavior here), Styles (voice everywhere), Skills (procedures), Connectors/MCP (live reach).
  • Remote connectors like GitHub and Google Drive work on every client. Local MCP servers need Claude Desktop.
  • When the work moves from humans clicking to software at scale, the same pattern lives in the Messages API (system prompt plus attached docs) and the Agent SDK.

What to do, from this lesson

These actions are compiled in the role's Playbook.

  • Version knowledge by replacing files, never uploading a second copy
  • Promote a tool to Claude Code once it needs secrets or a repo
See the full action playbook →