Yard Docs
Sign in
On this page

Prototypes

Have the agent mock a change on your product's own pages, review the screens on its page, comment and refine, then make a spec or a project from them.

Updated November 11, 2026 · 13 min read

A prototype shows a change before anyone specifies it. It is a page of its own, listed under Prototypes in the sidebar: a gallery of screens the workspace agent mocked on your product's own pages. You look at the screens, comment on the ones that are not right, and press Refine for the next round. When the screens say what you mean, you make a spec or a project from them.

A prototype is static pages and pictures of them. It is not deployed and it does not use real data.

Start one

There are three ways.

  • On a sheet, press Add, then Prototype.
  • Ask in the chat: "prototype bulk select on the assets page".
  • From a finished investigation: Build prototype.

Add, then Prototype opens the work composer in Prototype mode, with the blocks you selected as its context. Write the change in plain words, and name the page it starts from (an address of a running app, or a path in a repository). Specify sets, for this run only, the platform (web app, mobile, tablet), how many directions and which states to show.

Press Build prototype. The prototype is made in the Prototypes library and its block says Working, with what the agent is doing right now.

What the agent does

The agent works in a chat of the block's own. Open its log on the block shows that chat in the chat panel, with every step, and you can write to the agent there.

For the first round it:

  1. Captures the page as it is today. That capture is the first screen.
  2. Reads the page's source in the repository.
  3. Rebuilds the page as static HTML with your product's own styles.
  4. Applies the change, one screen for each state worth reviewing.
  5. Renders every screen at 1440 by 900, and at phone size when asked.

When the agent asks a question

The agent may need something from you before it can go on, for example which of two pages you mean. It asks in the block's chat, and the block says so: it shows Needs you and the question, and its primary button is Answer. Press it and the chat opens in the chat panel with the question as a form. Send your answer and the block is back to Working. The opened review shows the same question with Answer, and its row under Prototypes in the sidebar says Needs input. The prototype's page says Needs you next to its name and lists the questions over the screens (in their place before the first round), with Answer, which brings up its chat beside the page (full screen on a phone).

When there is nothing to go on

With context (linked blocks, a page to start from or attachments) the agent builds at once. A request with none of these, or one too vague to build from, makes the agent ask first, with questions in the chat. Each one names the prototype, so it is clear they are about the page to mock up, not about Yard: what the page in the prototype is for and who uses it, which platform the prototype is for, and References for the prototype, which you must answer:

  • Research similar products and designs;
  • Find reference images for me to approve: the agent saves candidate pictures to uploads/refs/ and asks you to approve them, each picture an option, before it builds;
  • No references, just start.

Meanwhile the block shows Needs your answers with Answer, which opens its chat.

The files are in the workspace, where Files shows them:

Code
prototypes/<name>/
  prototype.json          the manifest: title, rounds, screens, sources
  round-1/
    <screen>.html         one static page per screen
    assets/               the styles the pages use
    shots/<screen>.png    the picture of each page

The block reads as a storyboard. Under its title, a row of rounds shows each round made (with how many screens it has and what it was made from) and, dashed, the next round the open comments would make; press a round to review it. The capture of the page as it is today stands apart on the left, locked: it is the reference every screen is compared with, not a screen, so it takes no comments. Then each screen of the round as a picture with its name, the number of open comments on it, the start of the newest one and a tag: Changed, New, or Unchanged against the round before.

Under the screens, a line says what the round changed on purpose (from its change log), with What changed to open the review and its change log. Then the folder of the round (press it to open the folder in Files) and the block's actions. The footer counts the open comments on screens and on the whole round. The block has no floating bar: its actions are in its footer.

There is one primary button:

  • Answer while the agent waits for an answer to a question.
  • Refine with N comments while a comment is open.
  • Create spec otherwise.

Start work is always beside it.

Review and comment

Press the block's open button, or double-click a screen, to open the review. It is the same review as the prototype's own page, in a dialog over the board: the round switch, where it is used, the grid of screens with the number of open comments on each and Kept / Not kept, and the round's change log. Press a screen to show it large; Open page opens its page in a new tab. Refine with N comments, Start work, Write spec and Files are in its head.

Press a screen's comment count to write a comment on it, or answer one. A screen can have several comments, from several people; everyone in the workspace sees them at once. You can edit or delete your own while it is open: Edit and Delete sit under each of your comments and replies (Enter saves an edit, Escape cancels it; deleting a comment takes its replies with it). Once Refine has sent a comment it is what the agent was asked, and it can no longer be changed. There is no approve and no reject: a screen is right when nobody has a comment left.

A screen shown large says Click anywhere on the screen to pin a comment to that spot, and a Click to comment label follows the pointer over the picture. Click a spot (without dragging) to pin a numbered comment there, or drag to comment on an area. Words on the screen are picked from a list under the picture, for a comment on that text. Refine sends pins, areas and text alike. To comment on the whole screen instead, write in Comment on this screen under the picture and press Comment (or Ctrl/⌘+Enter). The comment fields grow with what you write.

A comment, a reply or a comment on the whole screen can carry attachments: press the paperclip beside the field for This device or a search over the docs and blocks, paste or drop a file on it, or drag a doc, a block, a prototype or a file from the sidebar or Files onto it. Up to ten per comment; an uploaded file is saved with the comment once its upload is in. They show as chips under the comment, and Refine gives them to the agent with it: files to read, docs and blocks as context. Comments on canvas blocks and on a spec take attachments the same way (see comments).

A screen shown large behaves like a small canvas: it fits whole, the mouse wheel zooms at the pointer (a trackpad's two-finger scroll moves it), a pinch, the +, − and 0 keys or the controls under it zoom too, and you drag it to move it, far in or out. Drag the frame's corner to resize it. Pins stay on their spot at any zoom.

On a phone the screens are one column, and a screen's comments open as a sheet along the bottom.

A prototype asked for from the work composer can say what it is for that run (Specify): the kind of thing (web app, mobile app, dashboard, landing page, email, slides…), how many directions, how finished it looks (wireframe, product styles or polished), and which states to show too (empty states, errors, loading, dialogs). The agent is told them as one line with the request.

Refine

Refine with N comments sends every open comment to the agent in one message, each with the screen and the page it is about. The agent makes the next round in round-<n+1>/:

  • A screen with a comment is reworked.
  • A screen without a comment is copied unchanged, except where a comment on another screen changes something it shows too (the brand name, the navigation, a shared header): that change is made on it as well.
  • A new screen is added when a comment asks for one.
  • A screen marked Not kept is dropped from the next round.

The block says Working meanwhile (the prototype's row in the sidebar shows its spinner on every page), and the round you were looking at stays until the new one is in. A comment you write while the agent works is kept for the round after.

On the prototype's own page, the Refine or start work button in the header (or ⌘J) opens the work composer on Refine while a round is open, with a chip such as "Round 24 · 6 comments": what you write goes with the comments as an overall comment, and the composer can send without words.

Under a round's screens, a Change log, round N says what the agent deliberately changed, each with why, and what it left untouched (it stays as in the app). The project made from the prototype is given the same list.

When the round is in, the comments it used are history. They are no longer counted and are not sent again. The round switch at the top shows earlier rounds, read-only, each screen with the comments its next round was made from.

Make a spec or a project from it

Create spec (Write spec on the prototype's page) puts the prototype in your context and opens the composer on the workspace overview with Write a spec first ticked: describe what to build and start, and the agent writes the spec in that project. The workspace keeps prototypes and docs; specs live in projects. To keep going without a project, refine the prototype instead.

Start work and Implement do the same with the spec switch off: the prototype is in the composer's context, ready to start.

Either way the project gets the pages, not only the pictures: the current round's folder is copied into the project's directory at the same path, and the prototype is listed in the project's context. Comments that are still open go with it: the project's first instructions list them per screen, as changes still to make. Comments a round already used are not sent.

Where it stands

A prototype's page says where it stands next to its name, so you do not have to work it out from the round number:

  • Making round N: the agent is making the first round, or the next one after Refine. A panel over the screens says what it is doing now.
  • Needs you: the agent asked a question and makes nothing until it is answered. The panel lists the questions, with Answer.
  • Stopped: the agent's turn ended with an error before the round was in. The panel has Open its log, to see why.
  • In review: the round is in. Beside it, how many comments wait for Refine.
  • Spec written: a spec block is joined to it, but no project was made from it yet.
  • In a project: a project was made from it (or from its spec), or links it. Several open ones say In N projects.
  • Done: every project made from it is closed or has its pull requests merged or closed.

A project decides over everything else: once there is one, more comments or a new round do not change the stage.

On a computer, a strip over the prototype's head says which project it is in, and replaces the stage beside its name while there is one: Project, the project's name, its status and the step its agent is at ("step 3 of 5"), with Open project. In two or more open projects the button reads 2 projects and opens a list of them with their status, the done ones under Done. Once every project is done, the strip names the project in green with its done status (Merged). Without a project the strip stays, quiet: Not in a project yet, with Link to a project (a list of the open projects to put it in) and Start work.

In the sidebar, a prototype in an open project has the project icon on its row. Under Used in, a project is tinted in its status colour, so it reads apart from a doc.

As chat context

Select a prototype and the agent gets its pictures, the paths of its pages, the open comments and what it was made from. Press single screens in the gallery to pass only those.

In a project

Ask a project's agent for a prototype and it writes one into the project's directory. The project page shows it under Made by this project, with the same gallery and review. Refine there writes to the project's chat. It stays in the project: it is not copied into the workspace's Prototypes.

A project's spec can show a prototype too: when the agent writes the spec of a change people see, it puts the project's prototype (or a small one it makes) under Visuals, beside a screenshot of the page today. Pressing a screen there opens it on the Screens tab. See pictures in the spec.

From an agent

An agent hands a round to its block with one command:

Shell
yard-canvas prototype prototypes/<name> [--link <block>]... [--block <id>] [--sheet <id>]

It reads prototype.json, checks that every page and picture it names exists, and makes the prototype block or updates the one that shows the folder. --link joins it to a block it was made from. --block fills a block that is already there, and --sheet names its tab when that is not the first.

A round that only made it into prototype.json (an agent that forgot the command, or a person who edited the folder) still reaches its block: Yard reads the manifest of every prototype block when an agent's turn ends and whenever the folder changes, and brings a newer round onto the block. The comments sent for that round become its history, so Refine no longer offers them.

Was this page useful?
Edit this page