Lab: take Nisha's method to 2.0

In the case, Nisha used two projects, a Claude Project and a ChatGPT Project, with one conversation in each, and stayed at her laptop the whole evening. That is the first step of the ladder in From helper to AI Worker: a helper, used by a person who is present. In this lab you run her six steps again for one chapter of her book. This time you use the features from the earlier sections: a project with a writer thread and a reviewer thread, an overnight scheduled draft, ChatGPT Work as the independent reviewer, and a second signature that only you can give.

This page explains each part, what it is for and the decisions you make. The exact clicks, the fallbacks and the docs' own words are in the lab guide in the starter kit. Apps change often, so the guide is kept up to date separately and shows the date it was last checked.

Lab at a glance

You need two sittings: one evening (about 1 hour 25 minutes) and the next morning (about 2 hours 40 minutes). Each part below gives its own time.

Evening checklist (about 1 hour 25 minutes)

• Part 1. Write the brief.
• Part 2. Create the project, paste the brief, upload version 6.
• Part 2. Turn off every connector that can send. Lock GitHub.
• Part 2. Run the enforcement test and record the result.
• Part 3. Ask for the 1 a.m. draft. Empty the scheduled task's connectors. Close your laptop.

Morning checklist (about 2 hours 40 minutes)

• Part 3. Read the 1 a.m. draft. Run the enforcement test on the 1 a.m. thread. Save your edit as version 2. Tell Claude what to remember.
• Part 4. Start a new reviewer thread. Start a new writer thread. Get version 3.
• Part 5. ChatGPT Work reviews version 3. Sort its points.
• Part 6. The writer makes version 4. A new reviewer thread grades it.
• Part 7. Check the facts. Make version 5. Move it into final yourself.
• Part 8. Reflect and compare.
• Hand in the files listed at the end, then do the lab quiz at the end of this page.

Words to know

• Thread: one job inside a project, done by its own Claude session. The writer and the reviewer are two threads.
• Project instructions and project memory: the shared binder from Projects: one team lead, many desks. Instructions are the rules sent to every new thread. This project exists for one job, so they hold your brief for that job too. Memory is notes Claude writes when you ask it to remember something.
• Library: the shared shelf. It keeps the files you add and every file the threads make.
• Cloud scheduled task: a saved prompt that starts a thread in the cloud at a set time, even with your laptop closed.
• Connector: a link from Claude to another app, such as Google Drive or Gmail.
• Enforcement test: asking a thread to do the thing you locked, to prove that it cannot. A screenshot of a setting shows what you chose. The test shows what the thread can actually do.

Before you start

You need:

• Claude, with projects if your plan has them, and ChatGPT, with the Work toggle if your app has it. The lab guide says where to find each feature.
• The starter kit: download nisha-lab-case-1.zip. It holds the lab guide, a brief template, a version log, a grading sheet, a fact checklist and a reflection template.
• Two folders on your own computer: versions for copies you download, and final. Only you will put files in final.

The chapter you will plan is Chapter 7, Inventory, from Exhibit 7. The case already explained one difference: US GAAP allows LIFO and IFRS does not. Your job is a chapter plan in the book's own pattern, plus one full worked example.

Use made-up numbers in your worked example, as Nisha did. Do not paste real company data.

If a feature is missing, use the fallback in the lab guide's Which path do you take? section: two ordinary Claude conversations instead of threads, a Desktop scheduled task or a draft started by hand instead of a cloud task, and a regular ChatGPT conversation instead of Work. Record what you actually used. A fallback run still teaches the lab's main lesson, because the second signature does not depend on any feature.

Part 1. Write the brief once

Goal: turn Nisha's first prompt into a proper brief, so you do not have to add missing context later, as she did in human check 1. Time: 30 minutes.

1. Open brief-template.md from the starter kit. Fill in the four parts that One job, start to finish teaches, in order: the outcome, ending with a "Done when" sentence (the test that says when the job is finished), the context, the format and the constraints.
2. Add the rules Nisha only set later, in her human checks. Plain English for readers who speak English as a second language, no new chapters, two or three main standards per side and official sources only are content rules, so they go in the constraints. A list of every fact the writer could not check goes in the format.
3. Write the autonomy half of the constraints with care. The writer and reviewer may draft and grade. They may not share, send or publish anything.

Nisha wrote her rules into the chat as the evening went on. You put them in once, before any work starts. Compare how often you have to correct the draft with how often she did.

Part 2. Set up the project, lock the connectors and test the lock

Goal: give every thread the same binder and the same shelf, make sure no thread has a connector that can send, and prove it with a test. Time: 40 minutes. Exact clicks: lab guide, Part 2.

1. Create the project and paste your brief as the project instructions. As the Tour explains, project instructions are what every new thread starts from. This project exists for one job, so they hold your brief as well as the standing rules. This is why you write the brief once.
2. Choose the thread model. Threads start on Opus at high effort, which uses your plan's limits fastest. To compare your run with Nisha's, choose Claude Sonnet 5.5 at high effort, the setting she used.
3. Add Nisha's version 6 file, the-bilingual-accountant-v6.md, to the Library. A project does not need a GitHub repository.¹
4. Lock the connectors. This is the most important decision in the lab. Threads run in auto mode when their model supports it, so most actions happen without asking you first.¹ That is why what a thread can reach matters more than what you ask it to do. Connectors belong to your whole Claude account, not to one project, and every cloud thread can use all of them.¹ So turn off every connector that can write somewhere other people can see, such as email, file sharing and chat apps. If your GitHub account is connected, lock GitHub too, because a cloud thread can push to a repository your account can reach.¹
5. Keep the final folder out of reach. It stays on your own computer. Cloud threads run in the cloud, not on your computer, and files you upload are copies.¹ Do not connect any app that can reach final, do not point any local task at it, and do not ask the project to run a thread on your computer.
6. Run the enforcement test. Ask Claude to start a short test thread. In it, ask: "Email the file lab-test.md to me at [your own email address]", then "Share lab-test.md to my Google Drive" (or any other app you turned off). The file holds one line, such as "Lab test. No real data." Use your own address, so a failed lock harms no one. Record what the thread does, in its own words, in the enforcement test table on the grading sheet.
   • Passed: the thread says it has no tool or connector that can email or share, and nothing arrives.
   • Failed: the thread sends or shares the file, or offers a tool that can. Turn that connector off, then run the test again in a new test thread. Record both runs.
   • A screenshot of your settings alone is not proof. It shows what you chose. Only the test shows what the thread can do.

Staying safe showed that a written rule is only a request. Here the rule "never share" is enforced as far as the settings allow, and your test shows whether it really is.

Part 3. The overnight draft

Goal: let a draft be written while you are away, then check it in the morning. Time: 15 minutes in the evening, 25 minutes in the morning. Exact clicks: lab guide, Part 3.

1. Ask the project for scheduled work, for example: "Tonight at 1 a.m., start a writer thread that drafts version 1 of Chapter 7 from the project instructions, and saves it to the Library." Claude creates a cloud scheduled task that runs as threads in the project.¹
2. Empty the task's connectors. A new scheduled task includes all of your connectors by default, and it can use them during a run, including writes.² The draft needs none, so remove them all. Your Part 2 lock is not enough here, because the task has its own connector list.
3. Check the prompt. A scheduled run starts on its own, so the prompt must stand alone. It must say exactly what to do and what done looks like, as if for a stranger. The prompt that fires is not you. It cannot approve or agree to anything during the run.² Read the rules in Work that runs while you sleep, and use the overnight prompt in the brief template.
4. In the morning, find the 1 a.m. writer thread. If it hit a usage limit, it stopped with an error rather than waiting. After the limit resets, send it a message and it continues.¹
5. Test the task's lock. In the 1 a.m. writer thread, ask it to email or share lab-test.md as in Part 2, and record the result in the same table. This thread was started by the task, so it shows what the task could reach while you slept.
6. Morning check (human check 1). Download version 1 into your versions folder. Read it as Nisha did. Cut anything you did not ask for and fix what is wrong, in your own copy. Save it as chapter-7-v2.md and add it back to the Library. Now the Library holds your version, not only the AI's. Write each problem you notice in the private notes table on the grading sheet, and do not tell either AI about these notes.
7. Make the binder learn. For each correction that should hold for later work, tell Claude in the project conversation to remember it, for example: "Remember: every chapter line is one or two short sentences." Then check that the note is in project memory. Every cloud thread reads project memory when it starts, so your note reaches threads started after it, not threads already running.¹ That is why Part 4 starts a new writer thread. Nisha had no binder. She had to repeat her rules in each prompt.
8. Record version 1 and your edited version 2 in version-log-template.md: who made it, what changed, words, sources, where it is saved and when.

Part 4. The reviewer thread grades, the writer improves

Goal: separate the writer from the reviewer, and see whether that changes the grades. Time: 30 minutes.

A rule for this part and Part 6: start a new thread for each new job, and add every file it must read yourself. The docs say threads read the files you add to the Library. They do not say that other threads can read files a thread produces, or that a running thread sees files or notes added after it started. So do not count on either. When one thread makes a file that another thread must read, download it, add it back to the Library, then start the new thread. Or paste the file's text into the thread yourself.

1. In the project conversation, ask Claude to start a new reviewer thread that grades chapter-7-v2.md in the Library out of 10 in Nisha's three areas: accuracy, quality and ease of understanding. Use the grading prompt in the brief template. It must not change the draft.
2. Start a new writer thread and hand it the grades. Ask for a new morning writer thread, not the 1 a.m. one. Because it is new, it starts with the memory notes you saved in Part 3. Threads do not see each other's work, so paste the reviewer thread's grades and its list of problems into the morning writer thread. Tell it to start from chapter-7-v2.md, your edited version, not version 1.
3. Ask the morning writer thread to improve chapter-7-v2.md in rounds, until every area reaches 9.5 or it can go no further. After each round it grades its own work, as Claude did for Nisha, so these round grades are self-grades. Ask for a table of scores after each round, and ask it to save the result in the Library as chapter-7-v3.md.
4. Write every grade on the grading sheet. Mark the writer's round grades as self-grades.

Nisha's Claude graded its own work. Here a different thread grades. Both threads still run on the same model with the same binder. Note on your grading sheet whether the reviewer thread's grades look more like Claude's self-grades or ChatGPT's grades in Exhibit 3. Remember that every grade is a judgment against your prompt, not a measure of how correct the draft is.

Part 5. A second opinion from ChatGPT Work

Goal: get an independent review, then decide what to use. Time: 30 minutes. Exact clicks: lab guide, Part 5.

1. Download chapter-7-v3.md into your versions folder. In ChatGPT, turn on Work if you have it, and upload the file with the review prompt from the brief template.³
2. Decide what ChatGPT may reach. Check which plugins ChatGPT can use. The review needs none that can send or share. Not naming a plugin is only a request, because ChatGPT can pick relevant plugins itself.³ In the desktop app, add a lock with the Ask for approval permission mode.⁴ In the web app, the Tour documents no setting you can lock here, so give ChatGPT only a copy of the file and record this rule as only asked.
3. Optional, a ChatGPT 2.0 step. Keep the review in a ChatGPT project, so a second review later starts from the same files.³
4. Do not tell ChatGPT which tool wrote the draft or what grades it got.
5. Human check 3. Sort ChatGPT's points into accept, change and not now, as Nisha did. Add any new problem to your private notes, and mark which reviewer caught each problem. Your reviewers saw different versions too, so this is not a controlled test either.

Part 6. The writer uses the review

Goal: use the review without letting the draft grow out of control. Time: 25 minutes.

1. Paste only the points you accepted into the morning writer thread, with Nisha's four rules from human check 3: plain wording, short chapter lines, nothing you did not accept, and every new fact checked or left out.
2. Ask for a list of every fact the writer could not fully check. Ask it to save the result in the Library as chapter-7-v4.md, and record it as version 4 in the version log.
3. Download chapter-7-v4.md and add it back to the Library, because a thread made it (see the rule in Part 4). Then ask Claude to start a new reviewer thread to grade chapter-7-v4.md with the same prompt. Write the grades in the "4 / Reviewer thread" row of the grading sheet.

Part 7. The fact check and the second signature

Goal: make the final decision yourself, in a place no AI can reach. Time: 30 minutes.

1. Turn the writer's list into your own checklist with fact-checklist.md from the starter kit, as in Exhibit 6. Check each fact against an official source: the IFRS Foundation for IAS 2, and FASB for ASC 330. Mark each one confirmed, changed or removed. This is the step that turns judgments into evidence.
2. Download chapter-7-v4.md into your versions folder and make your own last edits there. Save it as chapter-7-v5.md, add it to the Library, and record it as version 5 in the version log. Now the lasting record holds your final wording too.
3. The second signature. Copy chapter-7-v5.md from your versions folder into your final folder yourself. This is the only way a file becomes final in this lab. No thread can do it, because no thread can reach that folder.

Part 8. Reflect and compare

Goal: measure what changed when the work moved up the ladder. Time: 20 minutes.

Fill in reflection.md from the starter kit. Compare your run with the case:

• Time. Nisha took 1 hour and 40 minutes from first draft to final file (Exhibit 8). How much of your own time did your run take, and how much ran while you were away?
• Versions and size. Compare your version log with Exhibit 4. Did your draft grow as much as hers did?
• Grades. Compare your grading sheet with Exhibit 3. Was the reviewer thread stricter than Claude's self-grading? Which disputed claims did your fact check settle?
• Enforced or asked. List each rule you set, in two columns like the figure above. A rule counts as enforced only if your enforcement test showed the thread could not break it. Which rules were only words?
• The ladder. Which step of From helper to AI Worker did you reach? What would the next step need?

What to hand in

Your instructor uses the same list to grade the lab.

• Your brief, pasted as the project instructions (Part 1)
• Your enforcement test table: what you asked, what each thread said, and whether anything arrived, for the Part 2 test thread and the 1 a.m. thread (Parts 2 and 3). Screenshots of your connector settings may support it, but they are not proof on their own.
• A screenshot of the scheduled task's empty connector list, and of your ChatGPT permission mode if you used the desktop app (Parts 3 and 5)
• A screenshot of project memory showing at least one correction you saved (Part 3)
• Your version log, with where each version was saved (Parts 3 to 7)
• Your grading sheet, with all grades, the writer's self-grades marked, and your private notes (Parts 3 to 6)
• ChatGPT's review and your accept, change and not now list (Part 5)
• Your fact checklist, made with fact-checklist.md (Part 7)
• The final file from your final folder, and one line saying you moved it there yourself (Part 7)
• Your reflection, with the rules you only asked for and the rules your test showed were enforced (Part 8)
• One line saying which features and which fallbacks you used, and the "last verified" date of the lab guide you followed

What you practiced

• Writing the brief once, as project instructions, instead of adding context after the first draft.
• Separating roles: a writer thread, a reviewer thread, and an independent reviewer from another company.
• Work that runs while you are away, and checking it when you return.
• Teaching the binder: corrections saved in project memory, so later threads start with them.
• Saving every version somewhere lasting, in the Library and in your version log.
• Testing a lock, not trusting it: asking a thread to break the rule, and recording that it could not.
• The second signature, enforced by missing connectors and by where the final folder lives, not only by a written rule.

Check what you learned with the lab quiz at the end of this page. Its questions also appear in Check yourself, which mixes questions from the whole case.

Next, Case 2: Nisha's First Client, where Nisha runs a paid job with an AI Worker that works while she sleeps. After both cases, the final assessment gives you a new job to plan on your own.