Why I built Precipice

I think by seeing, arranging and moving things. I need an idea in front of me, next to the other ideas it touches, where I can drag it somewhere else and see what changes. Long linear documents don't work that way for me. I built Precipice for people like me: visual, spatial and kinetic thinkers.

The frustration

Early product thinking gets scattered. The idea lives in a doc. The flow lives in a diagram. The screens live in a design file. Each tool is linear or separate, so the links between them live only in my head.

The insight

For me, thinking is spatial. The connections between an idea, a flow and a screen are the thinking. So they should sit on one surface, side by side, where I can see them and move them. Precipice puts them on one canvas and keeps them connected.

What I built

Each workspace is a scape: an infinite canvas where every object is a note, a user journey, a wireframe or a long-form Markdown block, with the links between them drawn on the map. You start on Home with a prompt or a template, or with a blank canvas that has no structure at all. Select an object and an inspector opens beside it, so you edit without leaving the map. It runs in the browser and as a Mac app.

The part I care most about is how you talk to it. Precipice has a copilot, Scapi, and a lot of my design work went into what a conversation with it should feel like when the work itself is a picture, not a page.

How a session flows

This is the path through the app, from Home to sharing.

1. Open HomeDescribe what you're working on, or reopen a scape from your library.
2. Pick a templateBlank, Product concept, User journey, Screen flow or Research synthesis.Blank is an open canvas with no structure.
3. Build the scapeAdd notes, journeys, wireframes and scape blocks. Edit each one in its inspector.
4. Connect objectsDrag from one object's handle to another's to draw a relationship.
5. Ask ScapiStart from the composer on the canvas, or open the Scapi panel with ⌘J. An empty panel offers up to three suggested questions.Ask is the default mode. Nothing changes.
6. Scapi works, then answers"Working…" shows each real step, then "Responding" as the answer streams in.Stop keeps the partial answer, marked "stopped". Copy, Retry.
7. Edit, or Turn into an editSwitch to Edit, or turn a finished answer into a proposal."Review before editing": Apply proposed edit, or Cancel.
8. Watch it land, then Undo if neededChanges apply on the canvas with a running receipt. Stop keeps what landed. One Undo reverses the whole generation.
9. Or bring your own agentConnect Claude, ChatGPT, Codex or Cursor in Agents. Preview a flow in chat, then Create in Precipice, or review its changes on the canvas.
10. ExportDownload a .scape file to reopen in Precipice, or a PDF for sharing and printing.
11. PublishShare a read-only link. Later edits stay local until you choose Update public copy.

How it's organised

1. You talk next to the canvas, not instead of it

Scapi starts as a small composer at the bottom of the canvas. Ask a question there and the answer appears just above it, while the canvas stays in view. If you want the whole conversation, you open the side panel with one click or ⌘J. That is a change of surface, not a second chat: the canvas composer and the panel share the same draft, the same mode and the same transcript.

When you ask for a change, the result shows up where it belongs: on the canvas, as it happens. In my design notes, the canvas stays the working artifact and the conversation helps you read it or reshape it. For someone who thinks by looking at the map, the map should never be pushed off screen to make room for chat.

2. Ask and Edit: thinking out loud vs changing the canvas

One composer has two modes, and you pick one before you send. Ask is for understanding: find gaps, compare objects, trace connections, and optionally search the web. Ask has no tools that can write to the document, so a question can never change your work, even if you type "change this". Edit is for changing: create, refine, rename, connect or remove, applied as validated actions you can watch land.

The editor opens in Ask. Switching modes keeps your text and only changes the controls around it, so things Ask can't use, like object types and instructions, disappear when you're asking. The toggle is deliberately quiet so the Send button stays the loudest thing on screen.

I split them because naming the consequence before you hit send is what makes it safe to think out loud. You can brainstorm with Scapi as much as you want and nothing on the canvas moves until you say so.

3. From a good answer to a change, with a review step

Often an Ask answer is the change you want. Under a finished answer there's Turn into an edit. It doesn't touch the canvas yet. It stages the question and answer as a proposal under "Review before editing", shows what scope it will touch, and says plainly: "The generator will interpret the proposal above. You can undo the result." You apply or cancel. If you change your selection or scope in the meantime, the proposal is dropped so an old plan can't run against a new target.

It's an explicit bridge from advice to action. Talking stays free, and acting is always a clear, separate step.

4. Selection as a boundary, and you can always stop or undo

If you select objects before an Edit, Scapi can only change those objects and anything it creates in that run. Changes to other existing objects are rejected. In Ask, the selection just tells Scapi what you're asking about.

Stop and Undo are different on purpose. Stop ends future work: a stopped answer stays visible, marked "stopped", and changes already applied stay put. Undo reverses applied work, and a whole generation undoes as one step because its changes share a single transaction.

5. Outside agents get reviewed, and the key is yours

Claude or ChatGPT can work on scapes through MCP: read, search, create, edit and arrange. In supported hosts you can preview a whole flow inside the chat and choose Create in Precipice, or discard it, before anything exists. Every agent change goes through validated operations and revision checks and comes back as a review card with one-step undo. Agents get reviewed, not trusted.

AI uses your own Anthropic API key. There's no hosted key, because a shared key behind a public endpoint is a key anyone can spend. The proxy in between stores nothing, and on the Mac the key can live in the macOS Keychain. Without a key, the composer says so ("Add an API key in settings to ask") instead of letting you send a request that can't run.

The same thinking runs underneath: your scapes live on your device, in IndexedDB, not a shared cloud. You move them with a .scape file or a library backup, and publishing a read-only link is a separate step.

How Scapi talks

I wrote down how Scapi should behave in a reference doc and in its system prompt.

1. It starts by offering questions about your canvas

An empty panel explains what Ask can do and offers up to three questions based on what's on the canvas. Clicking one sends it.

2. It leads with the answer, briefly

The prompt asks for the answer first, plain sentence case, no filler and short replies. Scapi also says when the canvas doesn't cover something, instead of guessing.

3. It's honest that asking can't change anything

In Ask, Scapi has no tools that write. The prompt tells it not to pretend otherwise and to offer the change instead.

4. Waiting is shown as what's actually happening

While Scapi works, a disclosure lists each real step, then folds away when the answer starts. A code comment in the panel rejects a placeholder like "Almost there…" as filler, because "a wait is far less annoying when it is legible".

5. The answer's shape follows the question

Scapi labels each answer by what you asked for, like Summary, Comparing, Troubleshooting or Finding, and the prompt shapes it to match. Object names in answers become chips that select the object on the canvas.

6. It's clear about what it remembers

Scapi sends the last six complete exchanges as context. After a reload, earlier answers stay visible but the conversation starts again, and the panel says so.

Working with the AI tools you already use

Precipice runs an MCP server, so outside agents can work on scapes. Setup steps cover Claude, Claude Code, Claude Desktop, Codex, ChatGPT and Cursor.

1. Your agentClaude, ChatGPT, Codex or Cursor, in the chat you already use.
2. MCPA hosted connector, or the Mac app's built-in local server.
3. Precipice canvasThe agent reads, previews and proposes changes as validated operations.
4. Your reviewReview cards with one-step undo, or Create in Precipice from a chat preview.

What an agent can read. Its capabilities, your list of scapes, a scape, objects, the current selection, instructions and history (get_capabilities, list_scapes, get_scape, get_objects, get_selection, get_instructions, get_history).

What it can do. Create, duplicate and delete scapes, apply changes, arrange and focus objects, set instructions, export, and check, cancel or revert its own operations (create_scape, duplicate_scape, delete_scape, apply_changes, arrange_scape, focus_objects, set_instructions, export_scape, get_operation, cancel_operation, revert_operation). Publishing (publish_scape, unpublish_scape) needs your confirmation in the app.

Preview first. With preview_flow, Claude and ChatGPT hosts that support MCP Apps show the whole flow map, notes, journey steps and wireframes inside the chat. No empty scape is created while drafting. Create in Precipice applies it in one step, with the usual undo. share_flow_preview can share a read-only link to the draft.

Review. On the Mac, the first local write asks for review. You can choose "Always apply changes from this agent". Deleting a scape always requires review. With the hosted connector, you choose all or selected scapes, read-only or edit access, and review or immediate application, and you can remove a connection at any time.

Setup, in plain words. Open Agents in the sidebar, or Settings, then Agents. On a Mac, pick Claude Desktop, Codex or Cursor and click Add, then restart the client. Claude Code gets a command to copy. For the hosted connector, you sign in with Google, through the same invite gate as publishing, and approve access. There are no ports, pairing codes or accounts for local use.

Why it matters. Your scapes become context for the AI tools you already use, and changes still land on one canvas you review.

The Mac app

The Mac app and the web app share the same React editor, built with Tauri. Here's what it adds:

• Your key in the Keychain. Check "Remember securely on this Mac" and the app loads your Anthropic key on later launches.
• A built-in local MCP server. Agents connect through a private socket on your Mac, with no ports, Node install or accounts. If the app is closed, the agent's next message reopens it.
• Its own library. Desktop scapes are separate from the browser's. You move work across with a library file or .scape files; nothing syncs automatically.
• Sign-in in your browser. Google sign-in opens the system browser, not a window inside the app.

It's ad-hoc signed for Apple Silicon, not notarized, and has no in-app updater yet. The latest release is 0.1.9, from 11 October 2026.

Features at a glance

Scapi Ask

Answers questions about the scape and has no tools that write to it, so asking never changes your work.

Scapi Edit

Creates, refines, renames, connects or removes objects as validated actions, applied on the canvas as they arrive.

Turn into an edit

Stages a finished answer for review before anything changes. It's an explicit step from advice to action.

Undo and Stop

A generation undoes as one step. Stop ends future work and keeps what already landed.

Inspectors

Edit the selected object beside the canvas, without leaving the map.

Templates

Start a scape from Blank, Product concept, User journey, Screen flow or Research synthesis.

Local storage

Scapes autosave in your browser, not a shared cloud. Exporting a .scape file is the safest way to move work between browsers or machines.

One writer at a time

With a scape open in several tabs, one tab writes and the others are read-only until you take over.

Export and library backup

Export a scape as a .scape file or a PDF. Back up the whole library as one file.

Publish

Invite-only. Shares a read-only snapshot at a link that stays the same when you update it.

Your own API key

AI runs on your Anthropic key. There's no hosted key, because a shared key behind a public endpoint is one anyone can spend.

Agents through MCP

Claude, ChatGPT, Codex or Cursor can read, create, edit, arrange and export scapes. Review cards, revision checks and one-step undo keep changes inspectable.

Flow previews in chat

See a whole flow inside a supporting chat before anything is created, then Create in Precipice.

Mac app

Keeps your key in the Keychain and hosts a local MCP server, with its own library.

Instructions

Standing guidance for how AI works, for every scape or for one scape.

Who it's for

It's for people who shape product ideas by seeing them and moving them around, and who want an AI they can think out loud with without losing control of the work. If you want your idea, your journey and your screens on one surface, connected, on your own device, it's for you.

Where it is now

Precipice is early and pre-1.0. Release 0.1.5 added in-chat flow previews, a new sidebar Home, and templates. 0.1.6 gave Scapi a mascot and let chat previews expand to full screen. The latest, 0.1.9 on 11 October 2026, keeps Scapi beneath the latest chat answer once it finishes. The Mac build is ad-hoc signed for Apple Silicon. It isn't notarized yet, there's no in-app updater, and there's no automatic sync between browser and desktop. Next up: signed Mac builds, then an in-app updater, which depends on signing.

It's free and open source under the MIT License. Try it at precipice.pages.dev, or read the code and the design docs on GitHub.