Projects

What you'll walk away with: a project you actually use, and the one-question test that tells you whether it briefs a chat or just stores files.

You need: both tabs, about 20 minutes, and one real body of work with two or three documents you own and could forward outside the firm — the plan, the key document, where things stand. The figure runs on the page; nothing to install.

First, thirty seconds of retrieval — from memory, not from the page: how does work survive a chat? Say it, then check it against lesson 05: only if you carry it — three lines of what it is, where it stands, what was decided — into the next window. You have retyped those lines enough times to resent them, and both products offer a place to put them once. That place is not a folder: a project is not storage you open but a set of pipes, connected for every chat you start inside it — and one question tells you the difference.

What a project turns on

Give the work a home. You have met the fixture behind Projects (both) twice already, as a line on a list — lesson 01's card of six fixtures and lesson 03's inventory of the window. Here is what that line meant: a scoped workspace with its own files and standing instructions. In the terms of lesson 02, a project is a pre-loaded window: everything you put in it becomes the briefing your chats start with — loaded whole above your message while the pile is small, searched for the relevant parts once it outgrows the window. Each chat begins briefed instead of empty; you decide what is in the project, the app decides what rides. The lever you hold, made standing. The idea has its own shelf entry: projects and folders.

Two pipes, then: the files, which you would fill anyway, and the standing instruction — the one people skip and the one that pays, because it is lesson 05's three-line handoff written once instead of at the top of every chat.

Make one

Make one in your first tab, named for the real body of work you brought.

One honest note: menus move. Both companies reshuffle their sidebars, so if the word is not where this says, look for the nearest thing that holds files and standing instructions.

Two or three files, not the whole drive, and one paragraph of standing instruction: the project is what every chat inside starts with, so a project with everything in it is a window with everything in it — lesson 08 showed you what that does to the line that matters. No project surface in one tab? Run the exercise there in ordinary chats, the standing instruction pasted at the top of each; the comparison still works.

What the window received

THE PLUMBING — WHAT FEEDS THE WINDOWSCHEMATIC — THE SHAPE, NOT THE SIZES

• project filesPROJECT
• standing instructionsPROJECT
• memory fileAPP
• this chat so farCHAT
• your newest messageYOU

CONTEXT WINDOWfinite — everything competes for it

MODEL

the app decides how much of each pipe fits — big piles arrive selected or condensed, not whole.

Read the right-hand tags first; they are the point. Five pipes feed one window, and the tag on each says who connected it: project files and standing instructions say PROJECT, memory file says APP, this chat so far says CHAT, your newest message says YOU. Two of the five are yours by standing decision — that is what a project is; the APP pipe is the app loading something on your behalf — that pipe is lesson 12's. The tagline, standing in a project connects its pipes; a bare chat starts with them shut, is the claim the exercise tests. The dashed line is this lesson's second half: the app decides how much of each pipe fits — big piles arrive selected or condensed, not whole. SCHEMATIC, says the badge: the shape, not the sizes. All five converge on one CONTEXT WINDOW, finite — everything competes for it, then the model. A project does not make the window bigger; it decides what gets to compete — lesson 03 counted that window.

Whole when small, selected when large — and you cannot see which. Confidence does not say what rode in, and neither does asking: an inventory of the window is a completion like any other, lesson 10's shape. So ask for something only the file can supply — the sentence that matters, quoted word for word, with the file it came from. Lesson 04 ran this check on one attachment, and a project's files ride in the same way, through the app's own reader — loading the window, automated — so it is the acceptance test here too.

Do this in ChatGPT and Claude

Your project: two or three files you own, one standing instruction. Before you send anything, add a line you will recognize to the end of the least central file — your own words, appearing nowhere else, checkable at a glance — and put that edited copy into the project in place of the one already there; two copies and the check tells you nothing. The project has the copy you handed it — editing the file on your disk changes nothing there. That line is how you find out what arrived.

Predict first, in writing: when a fresh chat inside the project is asked to quote from your files, will the quotes match word for word — and will the line you just added come back at all?

Chat 1 — the acceptance test. A new chat inside the project:

Answer only from this project's files and instructions. First: quote, word for word, the two sentences across these files that matter most for [the decision I am making], and name the file each one came from. Then quote, word for word, the last line of [the least central file]. If a sentence is not in front of you, write UNKNOWN instead of reconstructing it.

Observe, written down: do the two quotes match the files character for character; did it name the right files; did your line come back exact, changed, or UNKNOWN. Explain: an exact quote was in the window; an UNKNOWN on a line that is definitely in a file is either the app sending a selection — the dashed line, on your own material — or the line riding in unused, lesson 08's shape. You cannot see which, and both say the same thing: put it where it cannot be missed. Neither outcome is the machine being good or bad at its job; both tell you what to put where.

Chat 2 — the stranger window, inside the project. A second new chat, still inside it:

You are picking this work up cold, with no history. From what is in this project alone, tell me in five lines: what this work is, where it stands, what has been decided, what is still open, and what you would do next. Where the project does not contain the answer, write UNKNOWN rather than filling it in.

Observe: read the five lines against what you know. Every UNKNOWN is a hole in the project and names its own fix — a file to add, a sentence for the standing instruction. Explain: this is the test of a project and the only one that matters: a new chat with none of this conversation in it, briefed by the project alone, either picks the work up or it does not.

Chat 3 — the same question outside. A new chat in the same tab, not inside the project, and paste nothing: the same five lines, word for word. Predict first: what can a window with nothing of yours in it say about your work? Observe: it asks what project you mean, writes five plausible lines about nothing, or writes UNKNOWN five times. (Something true about your work means the app carried it in — a note it keeps about you, lesson 12 — and the model still read it off the window.) Explain: same app, same account, same question, same engine — the pipes were shut. That is the figure's tagline, run in your own tab.

Then the same three in the other tab, same files, same standing instruction. What repeats is the shape you can plan around; what differs is one product's surface on one day — and the move you keep is the quote request, not a preference.

---

Check your understanding: a chat inside your project answered from a file you never pasted into it. A chat outside it, asked the same question, had nothing to say. Same app, same account, same engine — so what was different, and what do you check before you trust the inside answer?

Check yourself first — then open one good answer+−

The pipes. Standing in a project connects two of them — its files and its standing instructions — so the app loads them into the window of every chat started inside it; the chat outside started with them shut, and a window with nothing of yours in it has nothing of yours to say. Nothing about the model changed between the two chats. The window did.

What you check is what actually arrived: the app decides how much of each file fits, so a big pile rides in selected or condensed, not whole. Ask for the sentence that matters, quoted word for word, and read it against the file — an exact quote was in front of it; a paraphrase or an UNKNOWN means fix the project, not the machine.

Your answer should have hit the pipes as the thing that changed, and the quote as the check on what rode in.

Use this the moment you catch yourself retyping the same three lines of context. Put them in the project once, then run the stranger test on it — a fresh chat inside, asked to pick the work up cold, tells you in five lines whether you built a workspace or a junk drawer. Next: Memory — the notes the app keeps about you, and loads on your behalf.