Documents it builds and edits

What you'll walk away with: the fixture that keeps a revision out of the chat — one document you edit in place — and the three checks that tell you it worked.

You need: both tabs, about 20 minutes, the project you made in lesson 11, and one short real thing you want written down — an onboarding checklist, a handover list, a weekly routine. Nothing to install.

First, thirty seconds of retrieval — from memory, not from the page: what does "same thing again, but with point four fixed" cost? Say it, then check it against lesson 05: a whole new draft, and the old ones do not leave — every later send re-packages all of them, and lesson 07 is what that pile does to the one line that matters. Both products carry a fixture that takes the draft out of the conversation and lets you change it in place; this lesson is what it is, how you check it, and what the finished thing becomes.

Where the draft lives

Both products offer this fixture under different words: the document panel, writing & code blocks (ChatGPT) · Artifacts (Claude) — a live document the AI writes and you edit directly. Ask for a change in a plain chat and the chat grows another full copy of the draft — scroll up and count. Ask in the document and the document changes; the chat holds the request, not a fourth draft. So when a thing will be revised more than once, ask for it as a document on the first send, not after the third copy — the prompt is in the exercise. The reference entry, documents the AI builds, carries the window arithmetic and where the thing sits. Chat text instead of a document is a shape with a move, not a limit of the machine — step 1 has the move.

What differs, and what doesn't

The job of this feature is identical in both products — what differs is the word on it, where it sits this season, and the trims around it: what exports, what shares, what it can run. Learn the job once; check the trims per product. Tutorials written a year ago use a name that one of these products has already retired; the decoder keeps today's name — writing & code blocks (ChatGPT) · Artifacts (Claude) — dated, beside the other product's. The names move. The thing itself has not.

The two do differ, and the comparison is one you run, not one you read — three questions, the same three in each tab:

1. what each one shows you while it writes — the document changing in front of you, or a block arriving in the thread;
2. what each lets you edit by hand, and what happens to your edit when the AI next touches the document;
3. what each does when you ask for one section rewritten — that section, the whole document, or a fresh copy in the chat.

The answers are a product on a day, not a rule for next month; run them yourself. Menus move — both companies rearrange their apps — so if the wording here is not what your tab says, look for the nearest control that opens a document you can type in.

When it stops changing

A finished document is material, and material needs a home the next window can read. Put it into the project from lesson 11 as a file and every chat started inside that project begins briefed with it — projects and folders is the reference. The next window then reads the finished thing without the conversation that made it — the chat was the script, as lesson 05 said — and a home that outlives both tabs, dated, findable, owned by you, is what lesson 16 builds.

Do this in ChatGPT and Claude

Open the project from lesson 11 in the first tab. The prompts are written for an onboarding checklist; for a handover list or a weekly routine, change the nouns and keep the shape. Send them in each tab. No project surface in this tab? An ordinary chat works; step 4 says where the document goes instead.

Predict first, in writing: will the reply arrive as a document you can type in, or as text in the chat? And when you ask for one section to be rewritten, will the line you edited by hand survive?

Step 1 — build it as a document. A new chat inside your project:

Write me a one-page checklist for [the thing you want written down]. Ask me up to five questions first — I would rather answer questions than get something generic. Put the result in an editable document I can revise in place — not just a chat reply.

Answer its questions. Observe: where the answer landed — a document you can click into, or text in the thread. Chat text? Send Put that in an editable document I can revise in place and watch what opens. Nothing opens? That is something true about this product on this day: keep one current version in a file you own, paste it in when you need it, and the rest of the exercise still runs.

Step 2 — edit one line by hand. In the document, change one line to something you will recognize on sight — a word nobody else would write there. Do not tell the chat you did it. This is the fixture: you are typing into the thing itself, not asking for a new version of it. Nothing lets you type into it? Ask the chat for that one-line change instead and write down the answer to question 2 — that is this product's answer today; your marker is then the line you asked for, checked the same way in step 5.

Step 3 — ask for one section rewritten. Back in the chat:

Rewrite only the section on [name one section of the checklist] so it fits someone doing this for the first time rather than someone who already knows the job. Leave every other line exactly as it is, and make the change in the document itself.

Observe — three checks, the acceptance test for a document:

1. Did that section change?
2. Is the line you typed by hand still exactly as you left it?
3. Did the chat grow another full copy of the checklist — scroll up and count.

Two out of three is information, not a failure: if the rewrite reached lines you did not name, name the section by its heading and ask again for that section only; if your hand-edited line came back changed, retype it and say which lines are yours to keep.

Step 4 — save it as project material. When it stops changing, put the finished document into the project's files. Menus move, so look for the nearest thing that holds the project's files — if nothing saves straight across, download the document and add it to the project's files the way lesson 11 did. Where the product has no project, keep that copy where you will find it tomorrow.

Step 5 — reference it from a new chat. A new chat with none of this conversation in it, started inside the project if you have one — otherwise attach the document, or paste it in.

The onboarding checklist is [in this project's files / attached to this message / pasted below]. Using only what it says, name the two steps a new hire is most likely to miss on day one, and quote the line each one comes from, word for word.

Observe: read each quote against the finished document, character for character — lesson 08's check, doing a second job. An exact quote was in the window; if it is the line you typed in step 2, the new window read the thing you saved and not a draft from the conversation, because that line exists nowhere else. Close but not exact, or no quote at all? What it read was not your saved document — check the save landed in the project's file list, or attach it and send again.

Explain: nothing about the machine changed between the chat version and the document version — only where the current draft sits. Hence the move: ask for the document on the first send, and save it the moment it stops changing.

Now the second tab. Same project setup, same checklist prompt, same document-panel request — go. It should take a third of the time, because you are not learning the ideas again, only the words.

When both exist, put the two checklists side by side and actually read them. Which would you hand the new hire tomorrow? Then score more than taste, because the taste question hides the useful ones: which one asked you the better questions before writing? Which showed you what it was using — your files, its search, anything you could check? Which was easier to revise in place? Write one sentence per product on the three questions from What differs, and what doesn't: what it showed you, what happened to the line you typed by hand, and what one section rewritten moved. Keep the note — it is the first line of your own answer to "which one," and it will change as you use both, which is exactly why nobody here will write it for you.

---

Check your understanding: you ask for point four to be fixed, three times. In one chat you end up with three more copies of the whole checklist; in the other, one checklist that has changed three times. Nothing about the machine is different between the two. So what is different, and what is the move that gets you the second one?

Check yourself first — then open one good answer+−

Where the draft lives. In the first chat the revisions are the conversation: scroll up and count them — three whole drafts, and every one of them re-packages into the window on every later send, competing with the lines that matter. In the second, the revisions changed one document that sits outside the conversation, so what you scroll past is three requests rather than three drafts, and there is exactly one current version to point the next window at.

The move is one sentence on the first send, before the copies start: ask for the result in an editable document you can revise in place. Then edit it by hand, ask for one section at a time, and when it stops changing, save it into the project — or attach it — so a new chat can read the finished thing without the conversation that made it.

Your answer should have hit where the draft sits as the difference, not the machine — and asking for the document first, rather than after the third copy.

Use this the moment a draft is going to be revised more than once. Ask for the document on the first send, change it in place, check that only what you named moved — and when it stops changing, save it where the next window can read it. Next: Connectors — what a connected tool puts in the window, and what it can do on your say-so.