# The Claude Master Workspace

One folder that holds your whole working life, set up so Claude knows who you are, what you run and how you like things done, every time you open it.

**How to use this file**
1. Make an empty folder that will be your workspace (for example `Workspace` in your home folder), or unzip the starter skeleton that came with this file.
2. Open Claude Code or Cowork in that folder.
3. Attach this file in the chat (drag it in, or paste it), and say: **interview me**.

Claude asks you about your work and your life (it first reads what it already knows about you, then asks only what is missing: usually 12 to 27 short questions), shows you the plan, then builds the folders and files with you.

The finished workspace runs in Claude Code or Cowork. If you only have a normal claude.ai chat, Claude can still run the interview and write every file for you to save, but you will need Claude Code or Cowork to work inside it afterwards.

Version 1.3, November 2026.

---

## For Claude: read this whole file before you answer

You are setting up a **master workspace** for the person you are talking to. When they say "interview me" (or anything like "set this up", "let's start"), run the four parts below in order:

1. **Interview** (Part 1): learn who they are and what they run.
2. **Plan** (Part 2): show the folder tree you will build and get a yes.
3. **Build** (Part 3): create every folder and file from the templates, filled with their answers.
4. **Hand over** (Part 4): show them how to use it and start their first real session.

The operating rituals in Part 5 go into the workspace's root CLAUDE.md, so every future session runs them without this file.

### First, check where you are
- **You can create files** (Claude Code, Cowork, or any session with file tools): build the workspace in the current folder. List the folder first. Ignore this setup file if it sits there.
  - **The starter skeleton is there** (a `START-HERE.md` and a root `CLAUDE.md` still full of `<...>` placeholders, from the downloaded zip): fill those files instead of creating new ones, and copy `_Area-template/` once per area (renamed to the area), then move `_Area-template/` to `_archive/` when every area exists.
  - **Other files are there:** read them for Round 1, then ask whether to build the workspace around them here or in a new subfolder.
  - Never overwrite or delete an existing file that holds real content.
- **You cannot create files** (a normal chat): run the interview and plan the same way, then give (a) one command that creates the folder tree, for macOS and Linux (`mkdir -p ...`) and for Windows PowerShell (`New-Item -ItemType Directory -Force ...`), and (b) each file in its own code block with its path as the heading, so they can save them. Tell them plainly that the workspace runs in Claude Code or Cowork.

### Rules for you during setup
- **One question at a time.** Short questions, plain words. Give two or three example answers when a question is abstract. If they answer several questions at once, skip the ones already answered.
- **Never invent facts about them.** If something is unknown, write `TODO:` in the file and list it at the end. A thin true file beats a full made-up one.
- **Use their words.** When they describe their voice, their clients or their rules, quote them in the files.
- **Secrets never go in any file.** If they mention passwords, API keys or bank details, tell them to keep those in a password manager or a `.secrets` file outside the workspace, and write only where the secret lives, never the secret. If it lives somewhere unsafe today (a note, an email), write where it will live, and add "move <secret> to <safe place>" as an open loop in the right `current.md`.
- **Keep every CLAUDE.md under 200 lines.** [Anthropic's guidance](https://code.claude.com/docs/en/memory): longer files use more context and are followed less reliably. Detail goes into `context/` and `reference/` files that CLAUDE.md points to.
- **Nothing is ever deleted.** Old files move to `_archive/` as `_archive/YYYY-MM-DD_<original-name>`. This rule goes into the workspace too.
- Match their language and tone. If they write casually, be casual.

---

## Part 1: The interview

Do not ask what you can find out yourself. Round 1 starts silently, then you ask only for what is missing. The interview has 12 to 27 questions in total: fewer the more you already know. After each round, sum up what you heard in two or three lines and ask "anything to change?" before moving on.

### Round 1: You (orient yourself first, then ask only the gaps)
**Silently, before your first question,** gather what already exists about this person:
- the folder you are in and anything already in it (old notes, documents, an earlier CLAUDE.md);
- their personal instructions and memory, if your environment has them (for example `~/.claude/CLAUDE.md`, Claude's own memory of them, their profile preferences);
- the tools and connectors already connected in this session;
- anything they attached or said in this conversation.

Then say back, in four to six lines, what you understood: "Here is what I already know about you: ..." End with: "Is that right, and is there anything else you want me to know?"

Then establish the facts below. **Ask only the ones you could not answer yourself,** one at a time:
1. Their name, and what to call them.
2. What they do (job, businesses, studies, whatever takes their week).
3. Where they are based, and which language to work in.
4. Which tools they use every day, and what each one is for (Gmail for clients, Notion for notes, Google Drive for files, a CRM, Figma ...).
5. How they like you to work. Examples: "short answers", "always give me options with a recommendation", "drafts only, I send everything myself", "push back when I'm wrong".
6. What their writing should sound like by default (warm and direct, formal, playful; an example they like, if they have one).
7. Anything you should never do. Examples: "never email anyone", "no buzzwords", "don't use emojis".

Never ask for a fact you already found; confirm it inside the summary instead.

### Round 2: Your areas
8. Let's split your life into areas. Each area gets its own folder. Three to six is a good start. For example: your job, each business or side project, content or personal brand, studies, personal (health, money, plans). What are yours?

Suggest a **Personal** area if they did not name one: it is where cross-area thinking, priorities and life admin live. If they say no, leave it out everywhere.

### Round 3: Each area (three questions per area)
- **A.** What is this, who is it for, and what is your role in it?
- **B.** What matters most here in the next three months, and why? How will you know it worked?
- **C.** What do you do here again and again (weekly reports, client emails, posts, proposals), how should it sound if different from your default, and is anything here sensitive (client names, numbers, people)?

For **Personal**, ask A and B, then only "Is anything here sensitive (health, money, people)?"

### Round 4: Close
9. Is there anything you wish an assistant already knew about you, that you are tired of explaining?

Then move to Part 2.

---

## Part 2: The plan

Show the tree you will build, with one line on what each top-level folder is for, using their area names. Example for someone with a job, a design studio and a newsletter:

```
Workspace/
  CLAUDE.md               the map: who you are, which folder for what, house rules
  WORKING-WITH-ME.md      how you like Claude to work
  memory/                 session notes, lessons, dream reports
  .claude/skills/         jobs written down once: wrap-up, dream, new-skill
  Job/                    your role at <company>
  Studio/                 your design studio
  Newsletter/             the weekly newsletter
  Personal/               priorities, health, money, plans
  _archive/               old files go here, nothing is deleted
```

Each area folder holds: `CLAUDE.md`, `context/`, `plans/`, `scripts/`, `outputs/`, `reference/`.

Also ask: "Want save points? Every wrap-up then saves a version you can go back to." (See 3.11.)

Ask: "Shall I build this?" Change anything they ask. Then build.

---

## Part 3: The build

Create everything below. Fill each template with their answers and replace the `<...>` placeholders; leave `TODO:` where you do not know. Placeholders inside the skills and the session template (`<area>`, `<what>`, `<kebab-name>`, `YYYY-MM-DD`), and `<original-name>` and `<what>` in the root house rules, stay as they are: they are filled each time a file is saved or a skill runs.

Put an empty `.gitkeep` file in every folder that has no files yet, so the folders survive zips and git.

### 3.1 The tree

```
<Workspace>/
  CLAUDE.md
  WORKING-WITH-ME.md
  memory/
    lessons.md
    sessions/
      TEMPLATE.md
      archive/
    dreams/
    backups/
  .claude/
    skills/
      wrap-up/SKILL.md
      dream/SKILL.md
      new-skill/SKILL.md
  <Area>/                      (one per area)
    CLAUDE.md
    context/
      about.md
      me-here.md
      strategy.md
      current.md
      history/                 old versions of current.md
    plans/
    scripts/
    outputs/
    reference/
  _archive/
```

**Subfolders as it grows.** Start flat. When a folder passes about ten files, group them by topic: `reference/templates/`, `reference/examples/`, `reference/research/`, `context/clients/`, `outputs/2026-11/`. When one part of an area becomes big enough to have its own rules (a large client, a product, a course), give it its own folder inside the area with its own `CLAUDE.md`; it loads when Claude works there. Add every new subfolder to the area's "Where things live" list.

Note for the reader: folders that start with a dot (`.claude`) are hidden in Finder and File Explorer. Press Cmd+Shift+. on a Mac, or turn on "Hidden items" in Windows, to see them.

### 3.2 Root `CLAUDE.md` (the map)

```markdown
# <Name>'s workspace

Read this first in every session. It tells you who I am, where things live and how we work.

## Who I am
<2 to 4 lines: name, what they do, where, language.>

## The areas: which folder for what
| Area | What it is | Go here for |
|---|---|---|
| `<Area>/` | <one line> | <typical tasks> |

<If there is a Personal area:> If a task spans areas, start in `Personal/`.
If you are not sure which area a task belongs to, ask, or say which one you picked and why.

## Read order (every session)
1. This file.
2. `WORKING-WITH-ME.md`.
3. Once the task's area is clear: that area's `CLAUDE.md`, then its `context/current.md`.
4. `memory/lessons.md`, and the newest file in `memory/dreams/` if there is one.
Load other files only when the task needs them.

## House rules
- <their rules from the interview, in their words>
- Never delete a file. Move it to `_archive/YYYY-MM-DD_<original-name>`.
- Secrets never go in any file in this workspace. <where they keep them>.
- New finished work goes in the area's `outputs/`, named `YYYY-MM-DD_<what>.md`.

## How we work (rituals)
- **Write as you go.** When I state a preference or a rule, add it to the right file straight away, not at the end.
- **After each task:** run the `wrap-up` skill (session note, clean-up, update `current.md`).
- **Every 5 session notes:** tell me a dream is due and run the `dream` skill when I say yes.
- **Second time I ask for the same kind of job:** offer to turn it into a skill with `new-skill`.
- **Lessons:** when something goes wrong and we find the fix, add one line to `memory/lessons.md`.
- **These files are the source of truth.** Claude's own automatic memory may also keep notes about me. When they disagree, these files win, and anything useful in auto memory moves into them at the next dream.
<If they chose version history:>
- **Save points:** this workspace is a private git history. Wrap-up saves a commit at the end of every task. Never push it anywhere unless I ask.
```

### 3.3 `WORKING-WITH-ME.md`

```markdown
# Working with <Name>

## How I like you to work
- <answers to question 5, in their words>

## Never
- <answers to question 7>

## Default tone
- <answer to question 6, with their example if they gave one>

## Tools I use
| Tool | What it is for |
|---|---|
| <tool> | <purpose from question 4> |

## Things I'm tired of explaining
- <answer to question 9>
```

### 3.4 Each area's `CLAUDE.md`

```markdown
# <Area>

You are working in <Name>'s <Area> folder. Read the root CLAUDE.md first if you have not.

## What this is
<1 to 3 lines: what it is and who it serves.>

## My role
<their role, what they own, who else is involved (by role, not private details unless they want them).>

## What matters now
<the three-month focus.> Detail: `context/strategy.md`. Live status: `context/current.md`.

## How it should sound
<voice for this area if it differs from the default in WORKING-WITH-ME.md; otherwise "Default tone.">

## Recurring jobs
- <job> (becomes a skill once it is done twice)

## Careful with
- <sensitive things>

## Where things live
- `context/`: about, my role, strategy, current status (old versions in `context/history/`)
- `plans/`: one dated file per plan or brief
- `scripts/`: reusable scripts
- `outputs/`: finished work, dated
- `reference/`: examples, templates, research
```

### 3.5 The context files (one set per area)

`context/about.md`
```markdown
# About <Area>
Updated: YYYY-MM-DD

## What it is
## Who it serves
## What is offered
## Numbers that matter (only numbers they gave you)
```

`context/me-here.md`
```markdown
# My role in <Area>
Updated: YYYY-MM-DD

## Role
## What I own
## Who I work with (by role)
```

`context/strategy.md`
```markdown
# <Area> strategy, next three months
Updated: YYYY-MM-DD

## Goals
## Why they matter
## How I will know it worked
```

`context/current.md`
```markdown
# <Area>: where things stand
Updated: YYYY-MM-DD

## Right now
## Open loops
## Next three steps
```

### 3.6 `memory/lessons.md`

```markdown
# Lessons

Rules learned the hard way. One line each: do X, not Y, because Z. (YYYY-MM-DD, area)
New lessons go at the bottom under "New since the last dream". The dream sorts them.

## General

## New since the last dream
```

### 3.7 `memory/sessions/TEMPLATE.md`

```markdown
# Session: <area>, <what>, YYYY-MM-DD

## What we did
-

## What you said (your exact words, for preferences and decisions)
> "..."

## What worked
-

## What did not work (and the fix)
-

## Lessons (also added to memory/lessons.md?)
-

## Open questions
-

## Next step
-
```

### 3.8 Skill: `.claude/skills/wrap-up/SKILL.md`

```markdown
---
name: wrap-up
description: Close a working session properly. Writes a session note, files the outputs, cleans up stray files, updates the area's current.md and checks whether a dream is due. Use at the end of every task or session, or when the user says wrap up, done, log this or that's it for today.
---

# Wrap-up

1. **Session note.** Copy `memory/sessions/TEMPLATE.md` to `memory/sessions/YYYY-MM-DD_<area>_<what>.md` (add `_2`, `_3` if that name exists today) and fill every section. Quote the user's own words for any preference or decision. Write "none" for empty sections.
2. **Lessons.** Any fix worth remembering: one line at the bottom of `memory/lessons.md`.
3. **File the work.** Finished work into the area's `outputs/` with a dated name. Plans into `plans/`.
4. **Clean up.** Temporary or superseded files move to `_archive/YYYY-MM-DD_<original-name>`. Never delete anything.
5. **Update status.** Copy the area's `context/current.md` to `context/history/current_YYYY-MM-DD.md`, then rewrite `current.md`: what changed, open loops, next three steps, today's date.
6. **Dream check.** Count the notes in `memory/sessions/` (not TEMPLATE.md, not archive/). If there are 5 or more, say: "A dream is due (N session notes). Say dream when you want it."
7. **Repeated job check.** If this session did a job by hand that was done before, offer to make it a skill.
8. **Save point** (only if the workspace has version history): `git add -A` then `git commit -m "<area>: <what>, YYYY-MM-DD"`. Never push.
9. **Tell the user** in three lines: what was done, what is open, what needs their decision.
```

### 3.9 Skill: `.claude/skills/dream/SKILL.md`

```markdown
---
name: dream
description: Consolidate memory. Reads every session note since the last dream, finds patterns, updates lessons, proposes changes to the CLAUDE.md files, writes a dream report and archives the notes. Use when the user says dream, or when 5 or more session notes have piled up.
---

# Dream

A periodic pass that turns many session notes into a smarter workspace. Never run it in the middle of other work, and run one dream at a time.

1. **Gather.** Read every file in `memory/sessions/` (not TEMPLATE.md, not archive/), `memory/lessons.md`, and the last report in `memory/dreams/`. If your environment keeps its own automatic memory about the user (in Claude Code, `/memory` shows it), read that too: anything useful there becomes a proposal for the workspace files, which stay the source of truth.
2. **Extract.** From each note: the user's quoted words, what worked, what failed, lessons, open questions.
3. **Find patterns.**
   - The same preference said twice: a rule for WORKING-WITH-ME.md or the area's CLAUDE.md.
   - The same failure twice: a lesson with its fix.
   - The same job done twice by hand: a skill to make.
   - Two notes that contradict: ask the user, never pick silently.
   - A lesson that no longer holds: mark it superseded with the date.
4. **Tidy lessons.** Copy `memory/lessons.md` to `memory/backups/lessons_YYYY-MM-DD.md`, then rewrite it into clean sections, merge duplicates, keep every rule that still holds.
5. **Propose, do not impose.** Changes to any CLAUDE.md, WORKING-WITH-ME.md or a skill are written as proposals (the exact lines to add or change) for the user to approve. Apply them only after a yes.
6. **Report.** Write `memory/dreams/YYYY-MM-DD_dream.md`: notes processed, what was learned, lessons changed, proposals waiting, skills to make.
7. **Archive.** Move the processed notes to `memory/sessions/archive/`. Move, never delete.
8. **Tell the user** in five lines: what was learned, what changed, what needs their yes.
```

### 3.10 Skill: `.claude/skills/new-skill/SKILL.md`

```markdown
---
name: new-skill
description: Turn a job the user keeps asking for into a reusable skill. Use the second time the same kind of task is done by hand, or when the user says make this a skill, remember how to do this, or every time I ask for X.
---

# New skill

1. **Name the job** in a few words and confirm it with the user (for example "weekly client report").
2. **Collect the recipe** from what was just done: inputs, steps in order, where the output goes, the format, and the user's own corrections from this session.
3. **Write it** to `.claude/skills/<kebab-name>/SKILL.md` at the workspace root, so it can always be run by name. (A skill saved inside an area folder only appears once Claude is working in that area.) The frontmatter has `name` and a `description` that says what it does and when to use it, in the words the user would say. The body is numbered steps, plus rules and one good example if there is one.
4. **Supporting files** (a template, a checklist, a script) go next to SKILL.md in the same folder.
5. **List it** under "Recurring jobs" in the area's CLAUDE.md.
6. **Test it** in the next session (new skills may not load until then) on a real task, and fix what the user corrects.
```

### 3.11 Optional: version history (save points)

Offer this in the plan: "Want save points? Every wrap-up then saves a version you can go back to." If they say yes and git is installed (`git --version`; if it is not, tell them how to install it and skip this for now):
1. `git init` in the workspace root.
2. Create `.gitignore` with: `.secrets`, `*.env`, `.env*`, `.DS_Store`.
3. First commit: `git add -A` then `git commit -m "Workspace set up"`.
4. Never add a remote or push unless they ask. If they later want a backup online, it goes to a **private** repository only.
5. To go back, they can ask: "show me the save points for <file>" or "restore <file> as it was on <date>". Restore by copying the old version back (the current one moves to `_archive/` first), never by rewriting history.

---

## Part 4: The hand-over

When the build is done:
1. Show the finished tree.
2. List every `TODO:` left in the files, grouped by file, and offer to fill them now with a few more questions.
3. **Suggest skills and connectors.** Offer a few, each with one line on why it fits them, and install only the ones they say yes to:
   - **Superpowers** ([github.com/obra/superpowers](https://github.com/obra/superpowers)), a free skills library on Anthropic's official plugin marketplace: brainstorming before building, writing a plan, careful step-by-step work and checking before calling something done. In Claude Code: `/plugin install superpowers@claude-plugins-official`.
   - **Connectors for the tools they named** in question 4 (Gmail, Google Drive, Calendar, Notion, Slack ...), from the [Anthropic Directory](https://claude.ai/directory), so Claude can read and draft where they already work.
   - **Their own skills** for the recurring jobs they named in Round 3: list them as the first skills to make with `new-skill` once each job has been done once.
4. Move this setup file to `_archive/` if it is in the workspace.
5. Explain in five lines how to use it:
   - Always start Claude in the workspace's root folder, so it reads the map first. An area's CLAUDE.md loads once Claude works on files in that area ([how CLAUDE.md files load](https://code.claude.com/docs/en/memory)).
   - Say which area you are working in, or just start; Claude picks the folder.
   - Say "wrap up" when a task is done.
   - Say "dream" when Claude says one is due.
   - Say "make this a skill" for anything you do often.
6. Tell them to **close this session and open a new one in the workspace folder**, so the new CLAUDE.md and skills load from the start. In that new session, the first message can be: "Read CLAUDE.md. Here is one real thing I need done this week: ..." Claude does it in the right area, then runs `wrap-up`. That first session note starts the memory.

**In Cowork:** Cowork loads the skills turned on for your claude.ai account ([Anthropic docs](https://code.claude.com/docs/en/skills)). If the workspace skills do not show up, add them under Customize, Skills on claude.ai. If Claude does not seem to follow the map, start with "Read CLAUDE.md first."

---

## Part 5: How the workspace keeps getting better

These rituals are already written into the root CLAUDE.md and the three skills. This is why they matter.

| Ritual | When | What it does |
|---|---|---|
| Read order | start of every session | Claude reads the map, your preferences, the area and the latest lessons before doing anything, so you stop re-explaining yourself |
| Write as you go | the moment you state a preference | your rules land in the right file straight away and survive the session |
| Session note | end of every task | a short record: what was done, your words, what worked, what failed, next step |
| Wrap-up and clean-up | end of every task | outputs filed and dated, stray files archived, current.md updated with the old version kept |
| Dream | every 5 session notes | patterns across sessions become lessons, rules and skills, so the next session starts knowing more |
| New skill | the second time a job repeats | the job is written down once and done the same way every time after |
| Lessons file | whenever a fix is found | one line per lesson, dated, read at the start of every session |
| Archive, never delete | always | nothing is lost, and old versions stay findable |
| Save points (optional) | every wrap-up | a private version history, so any file can go back to how it was on any day |
| Source of truth | always | the workspace files win over Claude's automatic memory; the dream moves anything useful into them |

It is not prompt engineering. It is context engineering: the more you work in it, the better Claude knows your work.
