Sandpaper turns a Claude Code- or Codex-generated HTML draft into a surface you refine in place — point, say, or edit directly, no terminal round-trip. The pitch, interaction modes, and product calls live in the records below; this page routes you in.
Claude Code writes your specs as rich HTML — diagrams, tables, mockups — because HTML shows the idea instead of merely describing it. But to change one line you alt-tab to the terminal and re-describe the thing you were just looking at. Claude regenerates a whole new document; you re-read it, find the next thing, alt-tab again. Linear, lossy, one thread. The friction was never the editing — it's the surface mismatch. the loop, side by side →
The bet: if you can read the rich document and change it in place — while an explicitly selected provider rewrites the file as the single source of truth and shows its live status — then design collaboration collapses from a terminal monologue into a fast, non-linear conversation on the page, and the artifact stays canonical enough to drive what gets built. Claude Code and Codex share the same durable brain while keeping provider context separate. spec §01 → provider decision →
The June-15 billing change that could split the credit pool is paused, not gone — so the brain is kept swappable as insurance. the billing watch →
Sandpaper is a local tool that turns an HTML document into a surface you refine in the browser. Claude Code and Codex are first-class toolbar providers: tab-local selection, explicit Make default, no silent fallback, separate page/provider sessions and transcripts, and no hidden context handoff. how it's built → the status chip §04 →
One invariant carries the whole design: the document on disk is the single source of truth. You, Claude Code, and Codex mutate the same file; the page reflects disk, never ahead of it. The server hashes actual selected-document bytes for Saved/Replied and Undo truth. Provider-reported external writes are only best-effort warnings and cannot be verified or undone by Sandpaper. the SSOT call → the component map →
Every scoped interaction starts the same way: enter Pick, then click an element, and Sandpaper resolves its nearest data-cid or a selector/snippet fallback. With the target scoped, there are three ways in.
| Way in | What it does | Edits via |
|---|---|---|
| Sand | Scoped AI edit — select a block and describe the change. The selected Claude Code or Codex adapter edits the file; the page live-reloads with a truthful Saved or Replied outcome. | selected provider |
| ✎ Hands | Direct manipulation — edit text, move a sibling block, delete it, or undo. Written straight to the file: no AI call. | you |
| ⇥ Sling | Copies a terminal-ready instruction for cross-cutting / multi-file work — you hand it across to the terminal that's already good at it. | terminal |
Sand and Hands are the two halves of one invariant — an AI file write and a human file write to the same source of truth. Sling is the deliberate seam: the page is the eyes, deep steering stays in the terminal. Point-and-say Sand plus direct text/move/delete/undo are shipped; screenshot paste, one-click presets, and branching remain planned. the modes §03 → modes & promise → Hands on the board →
The roadmap climbs a thin spine before it widens. The dual-provider round-trip, live status, scoped edits, and direct manipulation are shipped. Release qualification for v0.3.0 is next; screenshot paste, durable data-cid anchoring, branch & compare, and a long-lived provider process remain later work. roadmap §06 → the provider plan →
The one rung that's also a blocker: keeping annotations attached when Claude regenerates the whole HTML. Tracked as an open question and a named spec risk. the anchoring question → risks §07 →
Sandpaper made one hard pivot: the browser is the eyes, not the chat. An in-browser chatbox is just a worse terminal, so the wedge isn't chat parity — it's the two things a terminal can't do. The page makes state visible: the rendered artifact, the live status chip, even this project brain. And it makes the artifact touchable: point, Sand, Hands. Deep, cross-cutting steering stays where it's already good — the terminal, the mouth — reached by Sling. the pivot →
The discipline is knowing where it stops: a refinement loop for documents, not an IDE, not a Figma. The proof is in the dogfood — this very brain is served by Sandpaper, where Sand refines one page in place and Sling hands cross-cutting work over. We build Sandpaper with Sandpaper. where it stops → the dogfood pledge → who it's for →
The one-pager — pitch, modes, roadmap.
The experience, the modes, the status matrix.
Problem, bet, who it's for, the name.
The durable ledger — filter “product”.
How it's built — the bridge, the contracts.
The plan — what's shipped, what's next.