# Learn Claude — Part 6: Projects, Memory & Connectors — Your Claude Operating System

Everything so far happens inside one conversation. Professional usage means building **infrastructure around conversations**: persistent context, standing instructions, and live connections to your actual tools. This is the part where Claude stops being an app you visit and becomes a system you work in.

## Projects: persistent context done right

A **Project** bundles three things for an ongoing area of work:

1.  **Knowledge** — files and notes uploaded once, visible to *every* chat inside the Project
    
2.  **Custom instructions** — standing rules for how Claude behaves there
    
3.  **Grouped chats** — everything related, in one place
    

The payoff compounds: instead of re-explaining your situation in every conversation, the context is *ambient*. A "Job Search" project holds your CV and target roles; every new chat starts already briefed. Say only *"cover letter for this posting: \[paste\]"*.

## Engineering your Project instructions

This is where most people underperform. Instructions are a **system prompt you control** — treat them with Part 3-level care. A professional template:

```plaintext
ROLE: You are my [editor / analyst / senior dev reviewing my code].
CONTEXT: [2–3 lines: who I am, what this project is]
ALWAYS: [output format, tone, language level, length defaults]
NEVER: [emojis, filler praise, unexplained jargon]
WHEN UNSURE: Ask me one clarifying question instead of guessing.
```

Rules of thumb, learned the hard way:

*   **Short beats long.** 10 sharp lines outperform two rambling pages — every line is context spent on every message.
    
*   **Knowledge is for facts, instructions are for behavior.** Your pricing sheet is knowledge; "always quote prices in EUR" is an instruction.
    
*   **Stale knowledge poisons silently.** An outdated CV in the project means confidently outdated cover letters. Audit your Project files monthly.
    

## Project architectures that work

*   **The Blog Project** — knowledge: style guide, audience description, past top posts. Instructions: voice rules, formatting, SEO checklist. Every draft starts 80% on-brand. (This series is written inside one.)
    
*   **The Codebase Companion** — knowledge: architecture notes, conventions doc, key schemas. Instructions: "match our patterns; flag breaking changes explicitly."
    
*   **The Client Project** (one per client) — knowledge: brief, contract scope, correspondence summaries. Instructions: their tone, their terminology. Context-switching between clients becomes instant.
    

## Memory and preferences: the cross-cutting layer

Outside Projects, two account-wide layers travel with you:

*   **Preferences (Settings)** — your global standing instructions, applied everywhere
    
*   **Memory** — Claude can retain useful details across conversations. Professionals *curate* it: review what's stored in Settings, delete the noise, keep the durable facts. Treat it like a colleague's notes about you — accurate and current, or corrected.
    

Precedence intuition: Preferences set your global defaults; Project instructions specialize them; the conversation itself can override both.

## Connectors: Claude reaches into your tools

The final layer, and the most quietly transformative. **Connectors** (built on an open standard called **MCP — Model Context Protocol**) let Claude securely access other apps you authorize: Google Drive, Gmail, Calendar, Notion, GitHub, Slack, Asana, and a growing directory.

The shift in what a prompt can be:

*   "Find our Q3 planning doc in Drive and summarize the open decisions."
    
*   "Check my calendar and draft a reply proposing times I'm actually free."
    
*   "Look at the last 20 GitHub issues and cluster them by root cause."
    

No copy-paste. Claude reads (and, where you permit, acts) at the source. You enable connectors in Settings and authorize each one explicitly.

**Professional caution, stated plainly:** a connector that can *act* (send email, edit tasks) deserves more skepticism than one that only *reads*. Grant minimal scopes, and review before Claude executes anything irreversible. Power tools, respected.

## The complete stack

Notice what you've assembled across six parts:

> **Preferences** (who you are, always) → **Project** (this domain's knowledge + rules) → **Connectors** (live data) → **Conversation** (the task at hand) → **Artifact** (the deliverable)

That stack — not any single feature — is what "professional Claude usage" actually means.

## Exercise

Build one real Project this week using the instructions template above: 3 knowledge files, 8–10 instruction lines. Then connect one read-only connector (Drive or Calendar) and run a prompt that touches both. Note how short your prompts have become — that's infrastructure doing the work.

## Next up

**Part 7:** coding — from chat-assisted programming to **Claude Code**, the agentic tool that works in your repository like a colleague.