---
title: "How to get feedback on a prototype right on the page"
description: "Publish a prototype at name.cool.computer, invite reviewers by email, and let them pin comments and drawings to the page for your agent to act on."
canonical: "https://www.cool.computer/blog/get-feedback-on-a-prototype"
last_updated: "2026-11-17"
---
# How to get feedback on a prototype right on the page

> Publish a prototype at name.cool.computer, invite reviewers by email, and let them pin comments and drawings to the page for your agent to act on.

To get feedback on a prototype right on the page, publish it at `name.cool.computer` and share it with your reviewers. Everyone who can open the site can pin a comment to any element or draw on the page, and everyone there sees it as it arrives. Your agent reads those comments, makes the change, publishes again and answers each one with what it did.

There is no separate review tool to set up. The comments live on the page itself, next to the button or heading they are about.

## Steps

1. Install `cool`. On macOS or Linux:

   ```sh
   curl -fsSL https://cool.computer/install.sh | sh
   ```

   Windows and Homebrew installs are on [the CLI page](/install). Or paste the setup prompt from [/setup](/setup) into your coding agent and let it do steps 1 to 3.

2. Sign up, then publish the prototype as a private site. For a framework app, build it first and publish the output folder:

   ```sh
   cool signup --email you@example.com
   npm run build
   cool publish ./dist --name checkout-prototype --visibility private
   ```

   `cool signup` emails you a six-digit code to finish sign-up. Publishing never runs a build.

3. Invite each reviewer by email:

   ```sh
   cool share add checkout-prototype ana@example.com
   ```

   An existing Cool Computers user gets access at once; anyone else gets an email invitation and signs in with that address. There is no share link for a private site.

4. Reviewers open `https://checkout-prototype.cool.computer`, click Comment (or press C), click the part of the page they mean, type what should change and press Add. They can also draw on the page with the mouse to circle or mark something.

5. Let your agent listen for the comments you send it, under its own name:

   ```sh
   cool comments watch checkout-prototype --agent "Claude Code"
   ```

   While it watches, the Comment bar says it is listening, and a comment card has an Ask button named after it, such as Ask Claude Code. Press it to hand those comments to the agent. With no agent listening, Operator, the agent in the web app, takes them. The watch exits when comments arrive and prints the command that reads them; the agent runs it, makes the change, resolves the comments and starts the watch again for the next round.

6. The agent makes the change, publishes the same files again and answers the comment:

   ```sh
   cool publish ./dist --computer checkout-prototype
   cool comments resolve checkout-prototype comment_0123 2 --done --reply "Moved the total above the button"
   ```

   When only you can decide, it answers with a short question instead (`--asked`).

To read the whole board yourself, run `cool comments list checkout-prototype`.

### Walk reviewers through it first

The agent can leave comments too. This pins a note with a ring drawn around the price, so reviewers know where to look:

```sh
cool comments leave checkout-prototype --selector "#price" --text "Is this clear enough?" \
  --marks '[{"el":"#price","shape":"ring","color":"blue"}]' --agent "Claude Code"
```

## Why and when to use it

Use it when you want reactions to a working page, not to a picture of one:

- Feedback in context: A comment is pinned to the element it is about, so nobody has to describe where on the page they mean.
- Drawings for what words miss: Reviewers draw on the page itself with the mouse.
- Live for everyone: Everyone on the page sees each comment as it arrives.
- The fix follows the comment: The agent that built the prototype changes it, publishes a new release at the same address and replies on the comment.
- Private until you choose: Only the people you invite can open it, after signing in. `cool share public checkout-prototype` opens it to anyone with the link later.

## How it compares

Screenshots marked up in a chat or a design tool are quick to make, but the reviewer is commenting on a still image, and the notes stay apart from the page.

A shared document or a list of notes in an email works for any prototype. Someone then has to match each note to the right part of the page and pass it to whoever makes the change.

Dedicated feedback tools add comments on top of a site you already host. Cool Computers does the hosting and the comments together, and connects them to the agent that builds the page.

## Questions

### Who can comment on my prototype?

Everyone who can open the site. On a private site that is you and the people you invited. On a public site, anyone signed in to Cool Computers can comment.

### Can reviewers draw on the page?

Yes. They can draw on the page with the mouse, as well as pin comments to elements, and everyone on the page sees it.

### Does my agent have to be running for people to comment?

No. People can comment at any time. The agent picks up the comments you send it while `cool comments watch` runs; with no agent listening, Operator in the web app takes them.

### Can I get comments on a page with my own domain?

You can serve a site on your own domain with `cool domain set`, but page comments show on the `cool.computer` address, not on custom domains yet. Share the `cool.computer` address for review.

### Is it free?

Yes. Free costs nothing and needs no card, and comments and drawings are included. It holds up to 20 sites at once. Pro, USD 20 a month, adds VMs and lifts the limit on sites. See [pricing](/pricing).

### Which agents can act on the comments?

Claude Code runs the watch as a background command, Codex in one of its own background terminals, and Pi uses its own watch tool. Any MCP client can read and resolve comments with the `cool_*` tools. See [how it works](/how-it-works) and [other MCP clients](/mcp-clients).

For more on publishing the page itself, read [how an agent publishes a website](/blog/ai-agent-publish-website), or browse what others made on [/explore](/explore).
