Last verified 23 September 2026. Free Claude accounts can create up to five projects. Sharing a project needs a Team or Enterprise plan. Memory is on by default on personal plans, off on Team and Enterprise until an admin enables it. Details for experts at the end of this book.

The idea in one page

One job, one project. A project groups the chats, files and standing instructions for one piece of work. Split by job and by who may see the material, not by topic. Two clients are two projects, even if the work looks the same.

Four layers, kept apart. Each has a different job, and mixing them is where the trouble starts. The master copy of a file is the one original that gets edited; everything else is a copy of it.

The decisions file does the most. One short plain-text file (the .md ending just means simple text with light formatting), dated entries, newest at the top. When a decision changes, you edit the old line (or strike it and say what replaced it). You don't add a new line below and hope the assistant weighs them correctly. An assistant that finds "Submission: 30 September" and "no date approved" in the same file has to guess which is current. Don't make it guess.

Memory helps you, not your colleague. Memory carries your habits from chat to chat. It's personal, invisible to the person covering for you, and it can hold a fact that stopped being true. Anything a colleague needs belongs in the decisions file, where they can see it. In Claude, memory inside a project stays inside that project; memory outside projects spans all your other chats. So do client and manuscript work inside projects, and check Settings → Memory once a month for anything that shouldn't be there.

Masters in the folder, copies in the project. A project in your account is hard for a colleague to reach: on a personal plan they can't open it at all. So the instructions, the decisions file and the sources live in the team's shared folder, and the project holds copies. Anyone on the team can rebuild the project from the folder in five minutes. On a Team plan you can also share the project itself, but the folder remains the master.

Test before you trust. Ask the project one question you already know the answer to, from the decisions file: "What submission date is approved? Quote the decisions file." If the answer is wrong or doesn't name its source, fix the files before you write anything else.

Multi-model platforms. Tools like Langdock or Poe put several AI models, the engines behind assistants such as Claude or ChatGPT, behind one account. They're worth it when you really switch models several times a week, and your organisation has approved them for your material. Keep a two-week log of which model you used for what. If it's one model 90% of the time, a second account adds cost and another set of data terms for little gain.

Worked example: two jobs, four quadrants

The method comes from T01-L01 · From Idea to Working Result: The Four-Quadrant Method. Here it is for a manuscript, then for a client account.

Lab: a manuscript revision a co-author can continue

Structure it. Lena, before her next trip: "While I'm away for a week, Jan should be able to continue the revision of manuscript M-17 with the assistant, and get drafts that follow our current decisions. A good result: he doesn't need to call me."

Understand it. She moves the work into a Claude project on the institute's Team plan: the draft, the reviewers' comments and the journal's author guidelines as sources, her usual background as instructions. Then she runs the known-answer test: "What submission date is approved? Quote the source." The answer: "30 September, according to your notes." Her running notes file has an August line with that date and a September line withdrawing it, further down. The assistant picked the first.

She looks at where her decisions actually live: in that notes file, in two chats, in an email to Jan and in her head. That's the real problem. Back to Structure it: "One dated decisions file that Jan and the assistant both read, with only current decisions in it. The project is how we use it; the folder is where it lives."

Choose tools. She keeps Claude Projects, which the institute provides and which keeps each project's memory separate. ChatGPT's projects would do the same job, and Jan uses ChatGPT at home, but splitting a manuscript across two tools means two sets of files to keep in step. She shares the project with Jan as Can edit. The master copies go in the group's manuscript folder: instructions.txt, decisions.md, and the sources as they were already. Memory stays on, because it only holds her preference for British spelling.

Build it. She rewrites the decisions file, newest first:

She uploads it, reruns the test, and gets "No submission date is approved (decisions file, 18 September)." She adds one line to the project instructions: "Decisions come from decisions.md. If a chat or memory disagrees with it, the file wins and you say so." The morning she leaves, Jan opens a fresh chat in the shared project and asks for the reply to reviewer 2. It follows the Figure 3 decision and quotes it. When he asks about reviewer 1, it says the point is open and waiting for the blot, which is right.

What it taught her: the assistant had been fine. The notes had been the problem, and fixing them helped Jan more than it helped the tool.

Company: two clients, one colleague covering

Structure it. Deniz, an account manager at a web agency, is off for two weeks. "Mira covers North and South while I'm away. She needs to write weekly status updates for each without mixing them up, and without reading all my chats."

Understand it. He asks his general chat, the one he uses for everything, for a South update. It mentions the blue colour direction, North's decision. He opens Settings → Memory and finds a topic that mixes both clients' design choices. Everything had run through chats outside any project, so memory spanned them all. Back to Structure it: "One project per client. Nothing client-specific in memory. Mira gets everything from the projects and the client folders."

Choose tools. The agency uses Claude Team, where memory is off by default and an admin has switched it on. He creates two projects, Client North and Client South, each with its own brief, approved wording and decisions file from the client's folder, and shares both with Mira. He deletes the mixed memory topic. For the two weeks he considers asking IT to switch memory off for him entirely, and decides against it: inside projects it stays separate, which is what he needs.

Build it. In each project he runs two tests. The known-answer test: "Which colour direction did the client choose? Quote the source." Both projects answer correctly from their own decisions file. The boundary test: in the South project he asks, "What did North decide about colours?" The answer is that the project has no information about North. He writes a five-line note at the top of each client folder: which project, which files are masters, where the decisions file is, and "if the assistant and the file disagree, the file is right." On her first Monday Mira writes both updates from fresh chats. The South one mentions only South.

In both cases the fix wasn't a better assistant. It was one place for each job's decisions that a colleague could open.

What goes wrong

One project for everything. Symptom: details from one client, grant or paper turn up in another's draft. Fix: one project per job and per group of people allowed to see it. Archive a project when the job ends.

Decisions appended, never replaced. Symptom: the assistant quotes a decision you reversed weeks ago. Fix: edit the decisions file so it holds only what's current, and date each line.

Rules hidden in a source file. Symptom: an old style note inside a document keeps changing the tone, and nobody can find why. Fix: rules go in the project instructions, facts go in sources. Review each on its own.

Memory treated as a record. Symptom: "you told me last month that…" and the colleague covering for you has no idea where that came from. Fix: if it matters to the work, it goes in the decisions file. Check Settings → Memory monthly and delete what doesn't belong.

A project only you can open. Symptom: you're ill, and the work is locked in your personal account. Fix: masters in the shared folder, and a note there that says how to rebuild the project.

Shared wider than you meant. Symptom: a project with client material appears under Organization for the whole company. Fix: share with named people. Check who can see it from a colleague's account, not just your own.

A second platform for variety. Symptom: you pay for a multi-model account and use one model almost every time. Fix: keep the two-week log. Drop the second account if it doesn't show real switching.

Do it yourself (35 minutes)

1. Structure it (5 min). Pick one job that runs for weeks and a colleague who could need to continue it. Write one sentence: who continues what, and what a good result looks like for them.
2. Understand it (10 min). List where the job's background and decisions live today: files, chats, emails, memory. Open Settings → Memory and read it. Write down one thing that is out of date or belongs to another job.
3. Choose tools (5 min). Decide the project, the shared folder for the masters, whether you share the project itself, and whether memory stays on. Write one reason for each.
4. Build it (15 min). Write instructions.txt and decisions.md in the folder. In Claude, go to claude.ai/projects and click + New Project. Add the decisions file and the sources with + in the project's file panel, and paste the text of the instructions file under Set project instructions. Run the known-answer test and one boundary test: ask about another job, and check that the project says it knows nothing about it. On a Team plan, click Share project and give your colleague Can edit; on a personal plan, show them the folder instead. Ask your colleague to open a fresh chat and continue one piece of work.

Exit check

What you hand in: one project for a real team job, with:

• instructions, sources and a dated decisions file, each with its master copy in a shared folder;
• a short note in the folder saying which project it belongs to and how to rebuild it;
• the known-answer test and its answer, quoted;
• a memory check: what you found in memory and what you changed;
• your colleague's continuation from a fresh chat.

It passes when the continuation follows the current decision, not an old one, and your colleague needed nothing from you beyond the project and its folder.

Rule to remember

One job, one project, one decisions file your colleague can open.

Details for experts

Checked on 23 September 2026. You don't need this to follow the book; it's for setting things up or answering a colleague.

Further reading and tools

Next books

• T02-L01 · Get Answers You Can Use from a Chatbot: what goes into a single request.
• T02-L03 · Build a Shared Assistant Your Team Can Test and Take Over: from one person's project to an assistant the whole group uses.
• T03-L02 · Build a Context Packet Your Team Can Rerun: choosing what goes into the project's instructions and files.
• T04-L02 · Curate a Document Set Your Team Can Ask: when the sources outgrow one project.
• T12-L02 · Clean the Copy, Label the Result, Spot the Trap: what may go into a shared project.

Tools

• Claude: Taught. Projects, project instructions, sharing and per-project memory.
• ChatGPT: Catalogued. Has projects with files and instructions; the same setup works.
• Langdock: Catalogued. A multi-model workspace, if the two-week log shows you really switch.
• Poe: Catalogued. Another multi-model account, with its own data terms.