<!-- Markdown rendering of ai-review-guide.html for AI agents.
     The HTML page is the same content with diagrams and styling;
     this view exists so an agent spends its context on the instructions. -->
# Someone sent you a document to review. _You can hand the whole job to your AI._

A PitchStation review link — a contract, a proposal, a webpage — lets you comment directly on the document: select text to object to it, propose replacement wording, pin visual issues. No account, no signup. And if you work with an AI assistant — Claude Code or Codex in a terminal, or plain claude.ai / ChatGPT in the browser — you can hand it the link and let it do the reading and the commenting **as you**. This page shows every path.

## §01 The 30-second version

**Copy the full share link**

The whole URL you were sent, including everything after the `?` — that part is your access key.

**Paste this prompt into your AI**

Fill in the two highlighted parts. Works in Claude Code, Codex CLI, Cursor, or any agent that can make HTTP requests. **Using claude.ai or ChatGPT in the browser?** Use the prompt in §03 instead — same result, one extra paste.

**Open the link and check the Threads panel**

Everything your AI posted is there under your name. Reply, refine, or delete anything — it's your review.

**The prompt**

```
Review this document and leave comments on my behalf: <PASTE THE FULL SHARE LINK>

Fetch the page first — near the end of its HTML is a note for AI agents
pointing at a review-guide URL. Fetch that guide and follow it: it explains
how to read the document and post anchored comments through the review API.

Sign every comment as: <YOUR NAME — e.g. "Dana Wu, Acme Legal">

When you're done, list what you posted and anything you chose not to post.
```

That's genuinely all a recipient needs. The rest of this page explains what happens, what your AI can and cannot do, and how to review by hand.

[Diagram: Four ways to review — by hand, a terminal agent, a browser chatbot, or an extension — all landing as comments on one shared document.]

## §02 What your AI actually does

Every review-enabled share is **self-describing to AI agents**. The page carries a machine-readable pointer to a guide at `/s//review-guide` — protected by the same access key as the document itself — which teaches the agent the full loop:

- **Read the document.** The share URL returns the real HTML (for a multi-file bundle, each file is listed and readable individually).

- **Identify as you.** Comments need a human name behind them. The agent registers the name you gave it once; every comment it posts is attributed to that name, marked `(unverified)` so the owner knows it wasn't a signed-in account.

- **Post comments anchored to exact text.** A comment on a clause quotes that clause verbatim. The server **verifies the quote against the document** before accepting it — if the AI paraphrases, the comment is rejected with instructions to re-read and copy exactly, so a sloppy quote can never produce a comment that points at nothing.

- **Propose replacement wording.** For contracts, the strongest move: a _suggested edit_ shows the current wording and the proposed wording side by side, and the owner can accept or reject it with one click.

- **Read the discussion.** The agent can poll the thread to see the owner's replies and the status of each point (open / resolved / accepted / rejected).

🔒 **Your AI can't do anything you couldn't do by hand.** It uses the same access key you were sent, the same comment API the on-page widget uses, and the same rate limits. If the link is revoked or expires, both of you lose access together.

## §03 Using web claude.ai or ChatGPT (no terminal)

Browser chatbots can **read** the shared page (their browsing tools fetch URLs) but cannot **post** — they have no way to call the comment API. So the flow has one extra step: the AI writes the review as a structured block, and **you paste it into the page**, where every quote is verified and nothing publishes until you confirm.

**Give the chatbot this prompt**

It reads the document with its browsing tool and produces a `pitchstation-review` block.

**Copy the block it produces**

One fenced code block containing all its comments.

**Paste it into the page**

Open the share link → **?** in the review panel → **“Paste an AI review”** → paste → check the preview → **Post**. Comments the page can’t find are flagged and skipped, never guessed.

**Web chatbot prompt**

````
Read this document with your browsing tool: <SHARE LINK>
Also read <SHARE LINK origin>/s/<slug>/review-guide?k=<key> — the section
"If you cannot make POST requests" defines the output format.

Review the document as my representative. My position: <YOUR BRIEF>

You cannot post directly. Output your entire review as ONE
```pitchstation-review``` code block per the guide — quote every passage
VERBATIM (the page verifies quotes and skips anything it can't find), one
point per comment. I will paste the block into the page myself.
````

✅ **This flow has a safety property the direct one doesn't:** you see every comment in a preview, on the page, before anything posts. For a contract review where the comments speak for your side, that checkpoint is worth the extra paste.

🤖 **Agentic browser modes skip the paste.** ChatGPT's agent mode and Claude's browser extension drive a real browser — they can open the link and use the review UI directly: switch to Comment mode, select text, click to pin. For those, the §01 prompt works as-is.

## §04 Reviewing a contract with AI

For a contract or agreement, tell the AI what your position is — it reviews on your behalf, so it needs your instructions, not just the document:

**Contract review prompt**

```
Review this contract on my behalf: <SHARE LINK>
Fetch the page, find the AI review-guide note in its HTML, and follow it.
Sign comments as: <YOUR NAME>

My position: <e.g. "we are the customer. Payment terms must be net-30,
liability must be capped at fees paid, and we cannot accept auto-renewal
longer than 12 months.">

For each clause that conflicts with my position, post a SUGGESTED EDIT
(quote the exact current wording, propose the replacement wording, and give
a one-sentence reason). For anything merely worth discussing, post a plain
comment. One point per comment. Don't post anything about clauses that are
fine — summarise those for me instead.
```

### What happens across revision rounds

When the owner revises the document, it stays at **the same link** and your comments come along:

| If the owner… | Your comment… |

| --- | --- |

| kept the text you quoted | stays anchored to it, exactly where it was |

| revised the wording you flagged | is marked **✓ addressed** — they acted on your point; confirm rather than re-argue it |

| deleted the text entirely | is marked **⚠ orphaned**, with your original quote preserved — the point was never silently re-attached to different words |

| accepted / rejected your suggestion | shows that decision, with their reason, in the thread |

Your AI can read the changes too: `/s//changes` (same access key) returns every round’s note and a redline — `- removed` / `+ added` paragraphs — between rounds, so a returning agent knows exactly what moved without re-reading the whole document. The machine guide points agents at it automatically.

Returning to the link after a revision shows an _"updated since you read it"_ banner with the owner's note about what changed — a natural moment to run your AI over it again: _"the document was revised — re-read it, check which of my points were addressed, and comment on anything new."_

[Diagram: Returning after a revision: compare versions, read the /changes redline, then act only on what actually moved.]

## §05 Reviewing a webpage or design

Shared webpages (including multi-page sites shared as a bundle) take the same comments, plus visual ones:

- **Numbered pins** — in Annotate mode, click any element (a button, an image, a heading) to drop a numbered marker and comment on that spot.

- **Drawn boxes** — drag to outline a region ("too much whitespace here").

- **Viewport context** — every comment records the screen width it was made at, so "the menu is broken" made on a phone is understood as mobile-layout feedback.

- **Per-page threads** — on a multi-file bundle, comments attach to the page they're about.

**Design review prompt**

```
Review this website before launch, on my behalf: <SHARE LINK>
Fetch the page, find the AI review-guide note in its HTML, and follow it.
This is a multi-page bundle — review every page, and put each comment on
the page it belongs to (the guide explains fileId).
Sign comments as: <YOUR NAME>

Look for: broken or placeholder content, claims that overpromise, unclear
calls to action, inconsistent naming or pricing, missing legal basics
(privacy, contact), and copy that reads machine-written. Post one comment
per issue, quoting the exact text. Summarise anything structural that a
comment can't capture.
```

💡 **Where the AI can't click, you can.** An agent reads the page's HTML — it won't experience hover states, animations, or how the layout feels on your phone. The strongest review is both: let the AI sweep the content, then spend five minutes in Annotate mode pinning what only a human eye catches.

## §06 Reviewing by hand

Open the link and look for the mode bar in the bottom-right corner. The **?** button in the panel header shows this same cheat-sheet — plus a **"Copy the AI prompt"** button that produces §01's prompt with the link already filled in, and **"Paste an AI review"** for the §03 flow.

**View**

Read normally. Nothing you do here is recorded.

**Comment**

Select any text to comment on it or propose replacement wording.

**Annotate**

Click anything to drop a numbered pin; drag to draw a box around a region.

**Threads**

Every comment — yours and others' — with replies and statuses.

The first time you comment you'll be asked for a name. That's the entire signup. On a translated view (the Translate pill), the widget will ask you to switch back to the original before commenting — comments anchor to the original text so they survive revisions.

## §07 Good to know

- **The owner sees everything in one feed** — your comments, your AI's comments, and other reviewers', each attributed. There is no private draft state: posted means visible.

- **Check what your AI posted.** It signs your name. Open Threads after it runs; you can edit or delete your own comments (same browser/session — your identity lives in a cookie the AI's session also holds if it kept its cookie jar).

- **Rate limits are enforced** per reviewer per document. If your AI hits one, it should stop and tell you rather than retry in a loop — the guide instructs it to.

- **Don't paste the link anywhere public.** The URL contains the access key; anyone holding it can read the document and comment. Treat it like the document itself.

- You can review in your own language — comments may be written in any language; only quoted text must match the original document.

- **Plain text only** in comments (up to 4,000 characters). Markdown isn't rendered.

## §08 For senders: enabling this

Turn on document review when you publish (or later — same link):

| Surface | How |

| --- | --- |

| Share composer | tick **“Let viewers comment”** when creating the share |

| MCP / AI assistant | `pitchstation_publish` with `comments: true` — or add `comments: true` to a `pitchstation_replace` round |

| API | `POST /api/share` with `"comments": true` — for any client that can make an HTTP request |

### The owner’s AI loop: gather, draft, decide

You don’t read the feedback by hand either. On your share’s analytics page, the Review section has a **🤖 Use your AI** button with a ready prompt for whichever AI you use — each one reads the comments, drafts the revision, and keeps you in control of what publishes:

| Your AI | How the loop runs |

| --- | --- |

| Claude Code / Codex / Kimi (terminal) | Reads the feed (`pitchstation_comments`), drafts the revision and a per-thread decision list, **shows you both**, then on your go-ahead publishes (`pitchstation_replace`, announce) and records every decision (`pitchstation_comment_resolve`). Same link, comments re-anchor. |

| claude.ai / ChatGPT / Gemini (browser) | Reads the document and the comment feed with its browsing tool, outputs the revised HTML plus a decision list. You apply: **Replace** on your Links page uploads the new version; the accept/reject/resolve buttons on the Review tab record the decisions. |

| Browser-extension agent | Operates your logged-in session: reads the Review tab, narrates each decision before clicking it, and applies the revision through the Replace modal — you supervise in real time. |

[Diagram: A full negotiation, assistant to assistant: each side’s AI works its half, meeting in one audited thread.]

🔁 **A full negotiation can run assistant-to-assistant.** Their AI reviews and objects; your AI reads the objections and drafts round 2; every exchange lands in the same audited thread with a human name behind it — and both principals see everything before it publishes.

Then tell your recipient one sentence: _“Comment directly on the page — or if you use an AI assistant, paste it the link and ask it to review; it will find the instructions itself. Guide: pitchstation.ai/ai-review-guide.html”_. Your own AI reads the same discussion via `pitchstation_comments` and publishes revisions with `pitchstation_replace` — so a full negotiation can run assistant-to-assistant, on the record, with both principals in control.
