Curate a Document Set Your Team Can Ask

T04-L02 · Your documents & knowledge · Level 2 Power user · 14-minute read, plus 45 minutes of doing

The old policy gave the new answer

A customer service team sets up a shared document assistant with all its policies, so new colleagues can ask instead of interrupting. On day three, someone asks how quickly a service request must be acknowledged. The answer is clear, with a citation: within five business days. A colleague copies it into a reply. The citation is real. The policy is two years old. The current one says two business days. Both files were in the folder, named policy-final.pdf and policy-final-new.pdf, and the assistant picked the wrong one.

In a lab it's a group notebook of assay protocols for new students. A student asks when to record the quality-control reading and gets "after 24 hours", with a citation to the 2024 protocol. Since August the rule has been two hours. He loses a day of measurements.

In both cases the tool did what it was built to do: it found a passage and cited it. The problem was what had been put in. You are at Level 2 Power user: your team sees the result. A personal notebook with a stale file misleads you. A shared one misleads everyone who asks it, with a citation that makes the wrong answer look checked. This book shows you how to decide what goes in, keep it current, and give the job to a named person.

After this you can

• Write a short rule for what goes into a shared document set and what stays out.
• Keep a source register: one line per document with its version, its status and who confirms it's current.
• Trace a bad answer to the document that caused it, and fix the set before touching the prompt.
• Share the set with viewers and editors deliberately, and know what a viewer can still see.
• Name who keeps the set current, their deputy, and what triggers a review.

Before you start

• Books: T01-L01 for the four-quadrant method. T04-L01: asking your own documents and checking every citation. This book does the same for a set your team shares. T12-L01 for what may be uploaded where.
• A document assistant your organisation has approved for these documents. The lab example uses Gemini Notebook (formerly NotebookLM) on a Google Workspace account, Google's paid service for organisations. The company example uses a shared Claude project.
• The folder your team would want to ask, as it is today.
• Someone who can say which documents are current: the person who writes the protocols, the policy lead, the quality manager.
• A spreadsheet for the register, and one colleague to try the result.
• About 60 minutes: 14 to read, about 45 to do.

Last verified 23 September 2026. Everyone you share a Gemini Notebook with can reach its sources, even through the chat-only link. A personal Google account shares with up to 50 people. Claude shares projects only on the Team and Enterprise plans. Details for experts at the end of this book.

The idea in one page

A shared set is only as good as what's in it. The assistant searches the documents, finds passages that look relevant, and answers from them with citations. It can't tell a current policy from a superseded one (replaced by a newer version) unless something in the set makes that obvious. Two versions of the same rule, and it may cite either. A duplicate file, and one claim looks like it has two independent sources. A draft, and the draft becomes the rule.

Write the rule before you upload. Five lines, kept at the top of the register:

Purpose:     answer [which questions] for [which people].
Governs:     [which document types decide the answer], current version only.
Background:  [which documents explain but don't decide], labelled BACKGROUND.
Never in:    drafts, superseded versions, duplicates, personal data,
             anything not approved for this tool.
Kept by:     [name], deputy [name]. Review [monthly] and whenever a document changes.

Keep a register. One line per candidate document, in a spreadsheet outside the assistant:

The register shows what's in the set without opening the tool, and who said it was current. A filename never settles that on its own: "final-new" tells you nothing. Rename files so the name still makes sense on its own: NS7_protocol_LAB-P17_2026-08-15_CURRENT.pdf.

One current version in the set. Keep history in a separate archive, outside the set people ask. A SUPERSEDED label helps, but leaving the file out works better, because the assistant can't cite what isn't there.

Test with three questions. Before anyone else uses the set, ask: one question with a current rule, one with an exception, and one the set can't answer. You know all three answers. The first two should come back with the right citation. The third should come back as not found. If it comes back with an answer, something in the set is saying more than you think.

When an answer is wrong, fix the set first. Open the citation. Was the document meant to be in the set? Was a newer one missing? Were there two versions? Fix the set, then ask the same question again. Only if the right passage was there and the answer still went wrong is it worth changing the prompt (T03-L02).

Share deliberately. Most people get view access. One or two get edit access: the person who keeps the set and a deputy. Anyone with edit access can add a file, so everyone with edit access needs to know the rule. And sharing the set shares the documents in it: a viewer can open every source, whatever link you send them.

Name who keeps it. A set that was clean on launch day drifts within months. One person, with a deputy, checks it monthly against the register and whenever a document it contains changes.

Worked example: two teams, four quadrants

The method comes from T01-L01. Here it is for a set of lab protocols, then for customer service policies.

Lab: assay protocols the new students can ask

Structure it. Katrin, the group's lab manager, answers the same questions every October when the new students arrive. "A notebook they can ask about the NS-7 assay, which gives the current rule with a citation to the protocol, so they check the protocol and not me."

Understand it. She tries the quick route first: a notebook with the group's whole protocol folder, 38 files. She asks, "When do we record the quality-control (QC) reading?" The answer says after 24 hours, citing a 2024 protocol that was replaced in August. The current protocol says two hours. She asks two more questions and finds a copy of the QC guide cited twice as if it were two sources, and a half-finished draft cited as a rule.

The tool isn't the problem. Nobody has ever written down which protocols are current: the folder holds everything anyone ever saved. Back to Structure it: "Before any notebook: a rule and a register, confirmed by the protocol lead. The notebook only gets what the register says is current."

Choose tools. She keeps Gemini Notebook. The institute uses Google Workspace, has approved it for protocols, and the students already have accounts. Every point in an answer carries a citation they can open, which is the habit she wants them to learn. Students get Viewer. She and the protocol lead get Editor, nobody else.

She notes two alternatives for later. For protocols with unpublished methods the institute hasn't approved for Google, there is AnythingLLM, a document assistant that runs on a group computer so nothing leaves the building. For a version several people can reach, there is Heidelberg AI Desk, which does the same on the institute's own server. She doesn't need either yet.

Build it. She lists eight candidates in the register. The protocol lead confirms the status of each. Five go in: the current protocol, the QC guide, the interruption exception, the glossary, and one methods paper marked BACKGROUND. The 2024 protocol goes to an archive notebook that only she can open. The duplicate and the draft stay out. She renames the five files to the pattern and builds a fresh notebook: at notebook.google.com she clicks Create new notebook, chooses Upload a source and picks the five files. Then she runs the three test questions:

In the first week a student asks about a reading of 0.78, gets "mark it REVIEW and notify the quality lead" with a citation to the QC guide, opens the guide, and does exactly that. Katrin shares the notebook with the Share button, adds the students' email addresses as Viewer and the protocol lead as Editor. She puts two lines at the top of the notebook's first note: "Kept by Katrin, deputy the protocol lead. Reviewed on the first Monday of the month and whenever a protocol changes."

What it taught her: building the notebook took ten minutes. Deciding what belonged in it took an hour, and that hour is what made the answers right.

Company: policies four colleagues answer customers from

Structure it. Markus leads a customer service team of five. "A shared assistant my team can ask about our service policies and supplier schedules, which gives the current rule and the clause, so they can quote it to a customer."

Understand it. He has already met the five-day answer from the two "final" files. Going through the policy folder, he finds more: three copies of the delivery schedule, a glossary from 2022, and a supplier negotiation draft with prices nobody outside purchasing should see. That last one worries him most. In a shared set, every colleague could have opened it through a citation. Back to Structure it: "Customer-facing rules only, current versions only. Nothing from purchasing, nothing in draft, and a register that says who confirmed each file."

Choose tools. The company runs on Microsoft 365 and has Claude on a Team plan, approved for internal policies. Gemini Notebook would put a citation on every point, but the company hasn't approved it, so that's out. He creates a Claude project and clicks Share next to the project name. He adds his team by email with Can view and keeps Can edit for himself and his deputy. He wants every answer to name its clause in words his team can search for, so he adds a project instruction, the standing text Claude follows in every chat of the project: "Answer only from the project files. Quote the clause and give the file name and section. If the files don't say, write 'Not in our policies – ask Markus'."

Build it. The register gets nine candidates. Five go in, uploaded as the project's files: the current request policy, the outage exception, one copy of the delivery schedule, the current glossary, and the communication handbook marked BACKGROUND. The negotiation draft goes back to purchasing. He runs the three test questions: two business days with the request policy quoted; four days during a declared outage, from the exception; and "Can we offer a discount for a late delivery?", which comes back "Not in our policies – ask Markus". Before, it would have found the negotiation draft. A colleague uses the set that afternoon for a customer who asks about a late acknowledgement, quotes the clause, and checks it in the policy file herself. The register lives in the team's SharePoint folder, and a trigger goes into his calendar: whenever the policy lead announces a change, update the register first, then the project.

In both cases the fix came before the tool. A rule, a register and a named person made the answers right. The assistant only repeated them.

What goes wrong

Everything goes in. Symptom: answers draw on old meeting notes, other projects and background reading. Fix: write the rule first. Only documents that answer the named questions go in.

Two versions compete. Symptom: a real, cited, out-of-date rule. Fix: one current version in the set. Archive the rest where the assistant can't see them. Confirm status with the person responsible, not from the filename.

Duplicates look like agreement. Symptom: two citations to the same text make a claim look doubly confirmed. Fix: compare title, date and content. Keep one copy and note its origin in the register.

Nobody keeps it current. Symptom: the set was right in March and wrong by June. Fix: a named person and deputy, a monthly check against the register, and a review whenever a document changes.

Internal is taken to mean allowed. Symptom: a draft with prices or personal data goes in "because only colleagues can see it". Fix: sharing the set shares every document in it. Anything a viewer shouldn't open stays out.

A set problem treated as a prompt problem. Symptom: stronger instructions, same wrong answer. Fix: open the citation and check the register. Fix what's in the set, then rerun the same question.

A chat link treated as a lock. Symptom: you send the chat view link and assume people can't see the sources. Fix: treat every viewer as someone who can open every document.

Do it yourself (45 minutes)

1. Structure it (8 min). Write the five-line rule for one shared set: purpose, what governs, what's background, what never goes in, who keeps it.
2. Understand it (12 min). List the candidates in a register. For each, get the status confirmed by whoever is responsible. Mark in or out, with a reason. If this changes what the set should be for, rewrite the rule.
3. Choose tools (5 min). Pick the assistant your organisation has approved for these documents. Decide who gets view access and who gets edit access.
4. Build it (20 min). Rename and upload only the documents marked in (in Gemini Notebook: Create new notebook, then Upload a source; in Claude: the project's files). Run the three test questions and open every citation. Share it with the Share button, choosing view or edit for each person. Ask a colleague to use one answer in real work and check its citation.

Exit check

What you hand in: a shared document set with:

• the five-line rule at the top of the register;
• a register with ID, title, version or date, status, who confirmed it and when, and in or out;
• the three test questions with their answers and citations: a current rule, an exception, and a question the set can't answer;
• who has view and who has edit access;
• the person who keeps it current, a deputy and the next review date;
• one answer a colleague used in real work, and the citation they checked.

It passes when every document in the set appears in the register as current, the three answers match what you expected, and a colleague can find the person who keeps it current.

Rule to remember

A shared set answers with whatever you put in it, so put in only what's current.

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

• T04-L01 · Ask Your Own Documents and Check Every Citation: the citation check this book relies on.
• T04-L03 · Test and Fix the Document Assistant Your Group Relies On: when the right document is in the set and the answer is still wrong.
• T03-L02 · Build a Context Packet Your Team Can Rerun: choosing sources by hand for one question.
• T02-L02 · Set Up Projects a Colleague Can Pick Up: shared projects and dated decisions.
• T12-L02 · Clean the Copy, Label the Result, Spot the Trap: what may go into a set others can open.

Tools

• Gemini Notebook (formerly NotebookLM): Taught. The shared notebook in the lab example.
• Claude: Taught. The shared project in the company example.
• AnythingLLM: Catalogued. A local option for documents that must stay on your machines.
• Heidelberg AI Desk: Catalogued. The route to running a document assistant on your own server.
• Open Notebook: Catalogued. A free notebook tool whose code is public, which you run on your own server.