Interfaces

An interface is a small screen someone can use. You describe what it should do, it gets built, and you get a link to hand to whoever needs it.

It's for the moment a drawing stops settling the argument. Everyone in the room is picturing a different thing, and the fastest way to find out who's right is to put the thing itself in front of them. It's also where the small in-house tools live — the lookup, the calculator, the form your team keeps rebuilding in a spreadsheet.

It is not where you build something your product depends on. That's Workbench, and the difference matters: an interface is a sketch that happens to run.

Interfaces live in their own tab beside Sketches and Decks.

Making one

New interface creates a blank one. Or ask zv1 for what you want — "a form that triages a support ticket and shows the priority" — and it builds the whole thing, including wiring it to a flow you already have.

Asking is usually faster, and it's the way round that plays to what's here: zv1 can see your flows and shims, so it knows what to point the screen at.

If you'd rather start from something, zv1 can begin from one of four shapes:

• Blank — a title and nothing else, which is where to start unless one of the others is exactly right.
• Chat — a conversation against one flow, keeping the history so the flow sees the whole thread.
• Form — labelled fields, sent as one run, with the answer underneath.
• Decision — text in, a shim's answer out, with its confidence and what it recommends.

The editor

The interface runs on the right and its files sit on the left. Both are live: save and the running copy reloads.

• Save — ⌘S. If nothing has changed, ⌘S reloads the preview instead, which is what you want when a screen has got itself into a state.
• Run your changes — appears when the preview is behind what you've typed. Clicking it reloads.
• Files — New file adds one (page.html, style.css, app.js); the rail renames and deletes. Deleting takes the file's contents with it and can't be undone.
• Tabs and splits — Open to the side puts two files next to each other, and the seam between them drags. Move back collapses it.
• Undo — in the File menu, or the usual keys in the editor.

Anything that goes wrong while the screen runs collects in a problems panel at the bottom of the preview, with Hide problems to get it out of the way. It's the fastest way to see why something went blank, and it's what to paste at zv1 when you want it fixed.

What it can reach

An interface starts able to reach nothing. File → Files and access is where you give it something.

Search your workspace by name, filter to Flows or Shims, and add what the screen needs. Each one is pinned to a published version, so a screen you handed someone keeps behaving the way it did when you handed it over — republishing the flow doesn't change it underneath them. When a newer version exists you'll see it, and picking it up is a click.

Add only what the screen actually uses. What you haven't added, it can't run.

Publishing a version

File → Publish a version… saves where the interface is right now and numbers it for you. There's nothing to name.

Versions are what links point at. Publishing while people are using a link doesn't move them — they stay on the version the link was made against until you decide otherwise.

Sharing a link

Share mints a link against a published version. If you haven't published yet, the dialog offers to do it in the same step.

A recipient opens the link and uses the screen on its own. They don't need an account, and they see the published version rather than whatever you're in the middle of changing.

• Point a link at a different version — pick one, and everyone holding that link moves with it.
• Turn a link off — it stops working immediately, for everyone.
• Limits — every link comes with a limit on how many times it can be used and a date it stops working. It shows how many uses are left as it gets close.

Going back

File → History… lists every version with who made it and when, including the ones zv1 made. Go back to this restores one.

Going back is an ordinary save, so it shows up in the history itself and you can come forward again. Nothing is lost by trying.

Working with zv1

zv1 edits interfaces the same way you do, and you can both be in one at the same time — your editor picks up its changes as they land, and it picks up yours.

Ask for what you want changed rather than describing the code: "the priority should be a coloured chip", "ask for the customer's plan before it runs". Once you've had the interface open, zv1 can see the screen as well as the files, so "the layout is cramped on the left" is something it can act on.

If you've both edited the same file, both sets of changes are kept where they don't collide, and you're told which file it had to choose on.