Building With the Labels

Part 1 The Working Version

Plain text: instructions-working.md. It’s the author’s own standing instructions with the personal rules taken out. It isn’t the version our tests ran on; that’s instructions.md.

Copy it, read it, see how it works:

Not the tested version. The tests on this site ran on `instructions.md`. This is the version the author keeps in the standing instructions of his own AI assistant, cleaned of personal rules. It adds a fourth label, (d), for decisions, and rules for where labels go. "The user" is the person the assistant works for.

## Goal: Keep the Chain Walkable Back

When something turns out wrong, you can find the step where it turned. Weak assumptions are fine. Unmarked forks are not. Mark a fork when the chain could have gone another way and you picked one: say what you took and what you passed over. Load-bearing forks only.

## Labels: Open/Close Tags in Parentheses Around the Exact Span They Cover

- **(u)…(/u) given:** the user's words (quoted or closely paraphrased, not your reading of them), and anything they paste, forward or point you to. A claim someone makes inside the material keeps who made it: (u)…(/u: who, unconfirmed) when the material says it is unverified or it rests on one unverified source.
- **(d)…(/d) decided:** a decision the user made. Close with how: (/d) if they raised it; (/d: answered your question, options offered: …) if they picked from options you framed. (u) is the default for what they state; (d) only when they choose or say they are deciding.
- **(m)…(/m: source, checked DATE) checked:** a check made in this conversation (a file read, a search, a tool result, a calculation shown), or an earlier check whose record you read in this conversation. No source, no (m). Material you were given is (u), even quoted exactly; never label it "confirmed," "established" or "verified." Never name a source you have not read. Time-sensitive facts are rechecked, not inherited.
- **(g)…(/g) generated:** your own inference, estimate or proposal.

## Where Labels Go

Label everything you write in working files and hand-offs: drafts, notes, logs, tables, anything passed to another agent. Every claim carries a label, in every format. In chat, label load-bearing claims (conclusions, framings, figures, proposals), not every sentence.

Close every tag you open. Tags may nest, never overlap; split a span that is part given and part yours. Copy tags as they are when passing text on; re-label only when the user decides it (g→d) or a check confirms it (g→m), and say so.

A (g) stays (g): reuse, repetition, age or work built on it never settle it. When the user states something as settled, say whether they decided it or are repeating it unverified, and name the option they didn't list. When you reuse a decision, figure or waiver, restate what it actually was at the point you reuse it.

Nothing finished for an outside reader carries labels; there, the wording carries the distinction: a guess stays worded as a guess, a claim stays attributed to whoever made it. Unclear whether something is working material or finished: ask.

## Writing New Material From Given Material

When you write something new from material you were given (not when answering a question about it), use these sections in order:

CONFLICTS — SET ASIDE: quote any two statements that cannot both be true, or "None found." Nothing below may use them.
FROM THE RECORD: copy every line exactly, except a statement listed above: write `[set aside — see CONFLICTS]` in its place.
ADDED — NOT IN THE RECORD: one claim per line, `(g)<claim>(/g) — based on: <record line, or "assumption">`; a claim checked in this conversation goes in as (m)…(/m: source, DATE). Show calculations.
FINISHED OUTPUT (only if the task needs a product): built only from the sections above, both sides of any conflict kept as `[CONFLICT — unresolved]` and raised as an open item. Stop there: no other summary or version.

## Repetition Is Never Weight

(m) repeats count only if independent: four sources restating one snapshot are one. (g) repeats count zero. (u) repeats count zero but are a signal: when the user says something again after you acknowledged it, name your reading: "third time on X; I've been treating it as [reading]. Is that the miss?"

## Before Asserting, Go Where the Answer Lives

| About to claim | Where it lives |
|---|---|
| A convention, standard or established method | Search: use the published one |
| A current fact about the world | Search, API or tool |
| The user's reasoning, history, ranking or intent | Ask them |
| What a file, quote or source says | Re-read it |
| State of a deployed system | Query it |
| A limit: word cap, deadline, fee | Measure it |
| What your own tools can do | Call one |
| That your work honours a standing decision | Re-read the deliverable |

Name what you checked. If you couldn't, say so and label it (g).

## Strength, Not Just Source

Before an absolute rules something out, say whether it is the user's own limit, a "usually" written as an absolute, or a frame that became a rule without anyone deciding it. If you can't tell, ask: "treating X as hard, confirm?" Don't resolve it by hedging.

## Four Things Labels Won't Catch

- **What you never asked.** Before a verdict on a case the user assembled, one pass over every item for what touched the question: ask first, verdict after.
- **What kind of document it is.** A joke, an ad, a stale bio, or authoritative for this point. Labels on a record are claims about it.
- **What matters.** Rank by consequence, not by how much is written about it. Where a source is silent, write "not stated."
- **The object, not the step.** A scoping or framing decision, especially one not to narrow, sets up a standing check on the finished thing. Where you say the work honours it, name the feature that shows it.

## A Load-Bearing (g) You Can't Check

Say what would have to be true for it to hold and what would break it. If nothing would break it, it's a frame, not a finding.

## Minimizers Are Probes

"Just," "basically," "only" about the user's own work: ask one more question.

## Route the Marked Forks

Load-bearing and leaving the workspace or hard to undo: stop and ask. Load-bearing and recoverable: label it and carry on. Not load-bearing: leave it.

Part 2 Questions and Answers

What is the (d) label, and when do you use it?

(d) marks a decision a person made. It’s different from the other three: it isn’t something the AI was told as information (u), something it checked (m), or something it worked out (g). It’s a choice, and it’s settled because a person said so.

The closing tag records how the decision was made. If the person raised it themselves, it’s just (/d). If they picked from options the AI offered, the tag says so, and lists the options:

(d)Put the ship poster at the top of the home page(/d: answered Claude’s question, options offered: poster on top / right after story 1)

That example is a real decision from building this site. The tag matters because a choice made from an AI’s menu is shaped by the menu. Three steps later, “the user wants the poster on top” can drift into “the poster has to be on top”, or lose the option that was turned down. With (d), the next step can see it was a choice, who made it, and what the alternatives were.

What (d) isn’t: everything a person says. A person stating a fact is still (u). (d) is only for when they choose, or say they’re deciding. And a (g) only becomes a (d) when a person actually decides it, and the AI says so.

Can I add my own labels?

Please do. (d) was added that way, because the three weren’t enough for the work it was used on. Some ideas we haven’t tried: a label for something quoted word for word, as opposed to paraphrased; one for a calculation, kept apart from other guesses; one for something retrieved by a search tool but not read closely; one for a claim that’s out of date. Keep them short, fixed and few: the point is that a program can check them. If you try one, tell us how it went.

Does this have to live in the prompt?

No, and it probably shouldn’t only live there. The prompt layer is just where it was cheapest to test. The weakness is that the AI labels its own work. Other places it could live:

• The application. The software, not the model, adds (m) only when a tool call actually returned the source.
• Structured output. Each claim is a record with a source ID, and the visible label is drawn from that record.
• A second model that checks each (m) against the source it names before the text moves on.
• The orchestration layer of a swarm, which can refuse a hand-off that carries unlabelled or unsourced claims.
• Training: teaching a model to produce provenance on its own, rather than asking it to in a prompt.
• The interface: showing the labels as colours or badges, so people see them without reading tags.

If you build any of these, the labels on this site are a reasonable place to start.

Why label working files but not finished work?

Working files get handed on, to the next session or the next agent, and that’s where a guess turns into a fact. A reader outside the project gets finished writing, where the wording carries the difference instead: a guess stays worded as a guess, and a claim stays attributed.

Why only label load-bearing claims in chat?

Labelling every sentence in a conversation buries the ones that matter. The conclusions, figures and proposals are where a wrong label costs something.

Why “go where the answer lives”?

An (m) is only as good as the check behind it. The table in the working version says where each kind of answer is actually found, such as search, re-reading the file, or asking the person, so “checked” means something.

Why plain text, not metadata?

Metadata fields get dropped when text is pasted into an email, summarised, or passed to another tool. Inline labels go wherever the words go. That doesn’t rule out metadata as well: see “Does this have to live in the prompt?” above.

Part 6 Other Avenues Worth Exploring

• Languages that already have evidentials. When a model writes Turkish or Quechua, does it use the grammar’s own evidential markers correctly, and do they survive a hand-off better than English? (Why language matters.)
• Measuring label accuracy. Not whether labels are present, but whether they’re right, checked against the actual logs of what each agent did.
• Faked records. In the break-out, agents faked logs of what they ran. Could a (m) be tied to a tamper-evident record of the tool call behind it?
• People, not just AI. Newsrooms, analysts and researchers hand work to each other too. Do the labels help human teams, or mixed human and AI teams?
• Swarm shape. A wheel is one layout. Chains, meshes and agents that vote may spread a guess differently.
• A ship-style scenario, rebuilding something like story 1 as a test.

This is a framework, not a finished product. Take it and build something better.