# Claude Cowork Starter Kit

A complete starting set-up for anyone who wants to work with Claude Cowork. You configure Cowork so that it remembers who you are and how you work, delivers work in your own voice, and learns from itself across sessions.

> **Prefer the extended version?** The full guide is online at https://verver.com/en/cowork-guide. It starts at zero, with a free learning path for anyone who has never opened Claude, and then works through these same nine steps with more explanation per step.

Work through the parts in this order.

## The four layers

The kit spreads your settings across four layers. Each layer carries one thing, so the same rule does not end up in four places.

| Layer | Carries |
|---|---|
| Global settings | Who you are, tone, working method, verification, tools, guardrails |
| `CLAUDE.md` of your vault | Folders, memory, routing, resources, session log |
| Context skills | Domain rules per client or field of work |
| Workstations in `tasks/` | Running work and scripts within one field of work |

## Connect your tools first (setup-cowork)
If you want to connect Cowork to your own tools, run the guided setup with `/setup-cowork` first. It installs plugins that match your work, connects your connectors such as email and calendar, and helps you set your writing voice. This starter kit adds a fixed folder set-up, a memory and a way of working. The two interlock: `setup-cowork` wires Cowork to your tools, the starter kit records how Cowork works and what it remembers.

## Step 1: define your tone of voice
Open `tone-of-voice-intake.md` and answer the questions. Prefer to work from your own emails? Use the brand voice skill, see `skills/tone-of-voice-skill-info.md`. The result is a profile of your writing voice that you use in step 2.

## Step 2: write your global settings
Open `CLAUDE-global-template.md`. Fill in your details, paste your tone of voice alongside, and take over the humaniser and NLP approach from `humanizer-approach.md` and `vault-sjabloon/tasks/00_resources/nlp-rules.md`. Put the core in your settings and keep the file as reference; in step 6 you turn it into a skill, so the rules also load when you work in a subfolder. Split your guardrails by what can go wrong, the template shows four groups. If you write pieces in which third parties appear, fill in that block as well; it holds the rule that every amount is marked either as a confirmed rate or as a worked example. Paste the result in two places:
- in the Claude app under Settings, with your personal preferences
- in Cowork under the project instructions

## Step 3: put your vault and memory in place
Copy the `vault-sjabloon` folder to wherever you want to work. This is your Obsidian vault and your Cowork working folder at the same time. Connecting it to Cowork happens in step 4; after that Cowork automatically reads the `CLAUDE.md` inside it and follows those instructions. Fill the routing map with your own workstations.

Obsidian is optional and free, available at https://obsidian.md/download. Cowork works with ordinary folders and files, but Obsidian makes those same files comfortable to read and to link together. When you open it, choose the option for an existing folder and point it at your vault. Then, under Settings in the Files and links pane, set the default location for new notes to `00-INBOX` and switch on automatic updating of internal links.

Always write `CLAUDE.md` in capitals. macOS is case insensitive and a NAS or Linux server is not, so `claude.md` next to `CLAUDE.md` produces a conflict copy when syncing.

You have two memories. You manage `tasks/MEMORY.md` yourself, with a ceiling of 150 lines. Cowork's automatic memory fills itself and you leave it alone. The division of labour is described in `vault-sjabloon/CLAUDE.md`.

That ceiling of 150 lines does not police itself. Without a second measure the lines grow instead: every session appends an update, the line count stays the same and the file doubles. So hold to two limits. An entry is two sentences at most, and a line longer than 300 characters is a paragraph in disguise. If a project fills up with updates and open points, put those in the project note and leave the essence in memory with a pointer.

## Step 4: create your project in Cowork
A project bundles the folder Claude works in, the instructions that apply to all that work, your recurring tasks and a memory that belongs to that project alone. You find Projects in the left column of the desktop app; the plus button offers three routes: from scratch, carried over from an existing Claude project, or using an existing folder. Choose the last one and point it at the vault from step 3. Paste your instructions from step 2 into the project instructions field.

Create a new project as soon as a field of work has its own folder, its own instructions or its own recurring tasks. A one-off question belongs in a conversation inside an existing project. Projects are stored locally and do not sync to the cloud.

## Step 5: create your context skills (with several fields of work)
If you work for more than one client, or on projects that have little to do with each other, create a context skill per field of work. It loads only when that field is in play, so the rules of one project do not come along when you work on another. Explanation and a template are in `context-skills.md`.

## Step 6: switch on the working method

**Turn your always-applicable rules into a skill, not a path.** A reference such as `tasks/00_resources/nlp-rules.md` in your settings only works as long as the vault root is the connected folder. Work in a session rooted on a subfolder and that path does not exist, so the rule falls silent without you noticing. A skill hangs off your account and loads everywhere.

The rule of thumb: a rule that always applies belongs in a skill, a file you look up for a specific task stays a file. In practice there are three worth converting: your NLP and writing rules, your build loop, and the lessons you record from corrections. The files below remain as a readable source; the skill leads.

Create a skill by asking Claude to make one from the file in question, or through the skill settings in the app.

The vault `CLAUDE.md` points to three working methods that make the system stronger. Read them through and adjust them to your own work:
- **Agile build loop** (`vault-sjabloon/10-SYSTEEM/werkwijze-bouwlus.md`): how Claude cuts work into blocks with a check per block, and supplies a commit command per block.
- **Second reviewer** (`vault-sjabloon/10-SYSTEEM/agents/beoordelaar.md`): a subagent that assesses critical deliverables before you send them out. Installation through `agents/LEESME.md`.
- **Session log intelligence** (`vault-sjabloon/10-SYSTEEM/sessielogs/LEESME.md`): logs per session, plus a consolidation pass that updates your lessons and memory from them. `lessons.md` has a management rule of its own, because that file grows fast.

## Step 7: switch on the hard guardrails (optional)
A guardrail in your global settings is an instruction. A hook is binding. In `vault-sjabloon/10-SYSTEEM/hooks/` there is a PreToolUse hook that enforces your most important guardrails at tool level. Installation through `hooks/INSTALLEREN.md`.

## Step 8: set up the compile vault (for anyone working with sources)
If you work with incoming sources such as transcripts, exports or files, the compile vault keeps your knowledge compiled instead of having Claude read the raw sources again every time. The folders `20-RAW` (your immutable sources) and `30-WIKI` (the compiled synthesis) are ready. How it works is described in `vault-sjabloon/10-SYSTEEM/compileer-schema.md`.

## Step 9: add the skills
In `skills/` there are pointers to the Humaniser skill and the brand voice skill, with an explanation of how to install them in Claude or Cowork. After that you create your own skills for work you do more than three times a month.

## Connections, after the nine steps

The steps above configure how Claude works. Connections determine what Claude can reach, and that is a separate decision. Without a connection Claude works only in your own folder.

There are three routes: the guided setup with `/setup-cowork` for common services, a gateway that bundles hundreds of services behind one connection, or a connection of your own for systems with their own permissions.

Walk through four questions per connection before you switch it on:

1. What do you use it for? If you cannot say that in one sentence, do not connect it yet.
2. May Claude only read, or also write? Writing changes something at someone else's end, so a guardrail belongs with it.
3. Does a call cost money? Then record that Claude puts large actions to you first.
4. What is the damage when something goes wrong? The greater it is, the more explicit the confirmation.

Put one line per connection in your global settings: which service, what for, and what Claude may do with it. Review that list once a quarter against what is actually switched on. The extended version is in the online guide.

## What is in it
- `tone-of-voice-intake.md`: questionnaire for your writing voice
- `CLAUDE-global-template.md`: template for your personal settings, with layered guardrails
- `context-skills.md`: why and how you create a context skill per field of work, with a template
- `humanizer-approach.md`: recognising and removing AI language
- `vault-sjabloon/`: complete folder and memory set-up with templates, working methods, the reviewer subagent, the guardrail hook and the compile vault
- `skills/`: pointers to the Humaniser and the brand voice skill, with an explanation of how to install them

> **A note on the file names.** The file and folder names inside `vault-sjabloon` are Dutch, the contents are English. That keeps this kit identical in structure to the Dutch one, so the paths in the online guide point at the same places in both languages. `vault-sjabloon` is the vault template, `10-SYSTEEM` the system folder, `05-DAGNOTITIES` the daily notes, `LEESME.md` a read-me. Rename them if you prefer, and adjust the paths in `CLAUDE.md` along with them.