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:

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.