Shell & notes

Editing together↑ Why · A team gets a launch page ready together Three people on one page in launch week, one of them on a train: editing together is that week.

Two people editing one page today take turns, or one overwrites the other. Here the whole page is the document, and an AI is one more person on it.

Live

Every tab on a page edits the same page, live

Open a page in a second tab or window, and both are the same page, with nothing in between but the browser.

Edits made offline merge when you reconnect

Nobody's edit is lost and every copy ends the same, whatever order edits arrive in.

Devices and agents edit one page at once, through the relay↑ Why · Jo's notes and code are on every device, and still files Jo's notes are the same on the phone and the laptop, edited on both.

The same edits as between tabs, carried sealed between your devices.

You see who else is here, and where

A cursor and a selection per person, with their name, as in a shared doc.

Undo undoes only your own edits

Undoing my edit never undoes yours or the agent's.

Typing feels local

An editor that waits on the network feels broken; edits apply on your screen first and travel after.

The editor syncs over anything that carries bytes

The editor asks a transport only to send and receive bytes, so changing the transport changes nothing else.

Comments

Comment on anything, and the comment stays with it

On a word, a sentence or any element. A comment follows its text through edits and its element through moves.

Reply, resolve, and find resolved threads again

AI↑ Why · Sam lets an AI help, and decides what it sees The AI sees only the section Sam picks, and its edits wait to be taken.

The AI reads only what you send it, when you ask

You choose the provider and the model, or bring your own key, and the request holds what you selected and nothing else. With AI off, nothing about a page leaves the browser at all.

The AI edits through the same moves as a person

Insert a component, set a prop, change a style from the allowed list, move a block, change text. It has no way to write code.

The AI's edits are a suggestion you accept

They arrive on a copy of the page, shown as changes against yours, and merge only when someone accepts them, whole or in part.

The AI is a named collaborator

Its cursor shows while it works, its edits carry its name in history, and undoing them undoes only its own.

An agent's work arrives as a fork you approve

Merging the fork is a call, so policy answers allow, deny or ask, and an ask shows the diff between the fork and its base.

Changing the page↑ Why · Sam changes the café's page without waiting on anyone Sam changes the hours, the menu and a photo by pointing at them on the page.↑ Why · A team gets a launch page ready together One person changes the colours while another rewrites the words.

Most people can't change a colour, move a section or add a form without a developer. Here you point at anything and change it, and everyone sees it change.

Styles

The pencil picks any element and shows its styles

For each property, where its value comes from: set on this element, a theme token, or the component's default.

A style change shows for everyone at once

Change a token, and every use of it changes

Colours, type, spacing and radii are named tokens, so a theme is a handful of values, not a thousand edits.

Styles are a fixed list of properties and checked values

A style is data an edit writes, so it can hold nothing that loads or runs, and nothing that escapes the page. Any CSS goes in a stylesheet, drawn only where it can't escape (build/any-css).

Moving things

Drag any block anywhere, and edits to it survive the move

Dragging a section in most collaborative editors deletes it and inserts a copy, so someone typing in it loses their edit. Here a move is one operation.

Two moves of one block at once never duplicate or lose it

Cut and paste within the page is a move

So it keeps the block's identity, its styles and anyone's concurrent edits.

Components

Insert any component from the library

By typing / in the text or from a panel, like a block in a document.

A component's settings are a form, made from its schema

Each component declares its props and their types; the editor makes the form, and checks every value against the schema.

A new component is made from existing ones

Select some blocks, name them, and they become a component with the props you choose to expose, without code.

Changing a component changes every copy, keeping each copy's changes

As in a design tool: an instance follows its component, except where it was changed.

Source↑ Why · Priya adds what only code can do, and stops being asked for words Priya reads what an edit really changed, as text.

One button flips between the page and its source

The source is the page's text form, the same text git holds.

The source shows everyone's edits as they happen

Editing the source edits the page

A change typed in the source becomes the same edits a person would make on the page, so it merges with theirs.

A real app↑ Why · Priya adds what only code can do, and stops being asked for words Priya's booking widget comes from the app's source, built like any code.↑ Why · Sam changes the café's page without waiting on anyone The booking form keeps taking bookings while Sam edits around it.

The page you edit is the app, not a picture of it: its tabs switch, its forms submit, its charts draw, while you change the words around them.

Components with behaviour come from the app's source

Written by developers, reviewed, built and shipped like any code; the editor places and configures them.

Nothing an edit writes ever runs

An edit is a tree of component names, props, styles and text. There is nowhere in it for a script.

New code takes a rebuild

Code merged by two people can be valid and wrong, and nothing would show it, so new behaviour is written in the source and built, never pasted into the page.

Code drafted in a doc runs only once its pull request merges

A page that needs its own code drafts it as a text node; only the built module the merge records ever runs.

The page keeps working while you edit it

Any page renders, however edits merged

Two valid edits can merge into something no single edit made. The page draws an unknown or invalid part as a marked placeholder and never fails.

An app is a component: built code, state in docs

An app with real behaviour (the agent, a terminal, a calendar) is built in git like a counter, and everything it keeps (a transcript, its settings) lives in docs of its own, so it follows you to any device.

A schema change migrates content

So devices on the old release keep working while the new one rolls out.

Yours↑ Why · Sam changes the café's page without waiting on anyone Sam's page stays Sam's: in Sam's browser and files, with no server to trust.

Versions↑ Why · A team gets a launch page ready together Nobody loses work: anything can be gone back to.

Go back to any earlier version

Every editing session is a version you can see, compare and return to; returning is a new edit, so nothing is lost.

A page is readable text in git↑ Why · Priya adds what only code can do, and stops being asked for words Priya reviews a page's changes in the pull request already in use.

Each page exports to its text form, with its ids, and imports back.

Save a page as a file, and open it anywhere

A page kept in one browser is lost with that browser's data, so it is always one click from a file you own, with its history.

History is kept outside the doc too

A doc that merges badly takes its history with it, so each named version is also kept in git, as text.

An edit merged in git comes back as edits↑ Why · Priya adds what only code can do, and stops being asked for words Priya edits a page in git, and it merges with the live edits.

Private and shared

No server ever reads your page↑ Why · Sam lets an AI help, and decides what it sees Sam can say what was sent and to whom, because nothing else leaves.

There is no server for pages. Today they, their comments and their history are kept in this browser's storage; between devices they travel sealed.

A doc is the unit of sharing, of permission and of damage.

A reader cannot push; a writer cannot pass on a stranger's edits.

Merging, compacting and search happen on your devices.

Publishing

Published pages are plain HTML

Publishing renders a version to static HTML and CSS, and only components with behaviour load script. This site is the same.

Plain files↑ Why · Jo's notes and code are on every device, and still files Jo's notes open in the editor, and on disk they are still the same markdown files.↑ Why · Priya adds what only code can do, and stops being asked for words An edit in the editor is a diff of only its own lines in Priya's pull request.

A markdown file opens and saves back byte for byte

The doc is the truth and the file is printed from it, in the file's own format: every block keeps the lines it was read from, so a block nobody changed is written exactly as it was.

An edit changes only its own lines

A changed block rewrites only the span that changed, keeping its line breaks; a moved block moves its lines; a new list item or table row is written the way its neighbours are.

A file another program changed comes in as edits

What git or another editor wrote is taken in as the smallest edit, so every block keeps its id, its comments and its history, and the file printed back is what that program wrote.

Saving never overwrites a change made on disk

A save writes only over the version the editor last read; if the file changed since, that change is taken in and merged first.

Tags the editor can't draw are kept, and edited as text

A component only the site draws, such as <Serves />, shows as a placeholder with its settings, which can be changed, and is written back as it was.

A file on any of your machines opens in the editor and saves there

Open a machine's folder from the page and click a markdown file: it opens in the editor, and a second after you stop typing it is saved on that machine, changed by exactly your edit. The machine itself refuses a save made over a version it no longer holds.

A file changed on its machine comes into the open editor

What git or another editor writes on the machine shows in the open file within seconds, and anything typed meanwhile is kept.

Safe to change↑ Why · Sam lets an AI help, and decides what it sees An AI that could restyle the screen still can't make deny look like allow.↑ Why · Sam changes the café's page without waiting on anyone Whatever Sam changes, there's a way back to a page that works.

One bad change today can take down the whole screen, or another pane. Here some parts can't be edited at all, each pane stays in its rectangle, and there are several ways back, each independent of what it rescues.

Containment

The shell can't be edited live

Whatever shows you a change to approve can't be editable by whoever made the change: an agent that could restyle the ask could make deny look like allow.

A pane reaches nothing outside its rectangle

Not by writing, styling, the top layer, code or input.

Asks are drawn only outside every pane

A pane can draw a perfect copy of an ask, so the real one is the shell's, and no click inside a pane answers it.

Recovery

The address names the shell's version

Back previews an earlier version in this tab, and ?ui=safe ignores shell data entirely.

One chord can't be rebound or covered

Phones get a fixed gesture.

A broken theme can't hide the shell

A bad shell build boots the last good one

A change that could lock you out is a trial

A change to input or visibility, and every agent change, reverts in 15 s unless confirmed with the chord, which proves the escape still works.

#Editing together↑ Why · A team gets a launch page ready together Three people on one page in launch week, one of them on a train: editing together is that week.

#Live

#Every tab on a page edits the same page, liveproof

#Edits made offline merge when you reconnectproof

#Devices and agents edit one page at once, through the relayproof↑ Why · Jo's notes and code are on every device, and still files Jo's notes are the same on the phone and the laptop, edited on both.

#You see who else is here, and whereproof

#Undo undoes only your own editsproof

#Typing feels localproof

#The editor syncs over anything that carries bytesproof

#Comments

#Comment on anything, and the comment stays with itproof

#Reply, resolve, and find resolved threads againproof

#AI↑ Why · Sam lets an AI help, and decides what it sees The AI sees only the section Sam picks, and its edits wait to be taken.

#The AI reads only what you send it, when you askproof

#The AI edits through the same moves as a personproof

#The AI's edits are a suggestion you acceptproof

#The AI is a named collaboratorproof

#An agent's work arrives as a fork you approveproof

#Changing the page↑ Why · Sam changes the café's page without waiting on anyone Sam changes the hours, the menu and a photo by pointing at them on the page.↑ Why · A team gets a launch page ready together One person changes the colours while another rewrites the words.

#Styles

#The pencil picks any element and shows its stylesproof

#A style change shows for everyone at onceproof

#Change a token, and every use of it changesproof

#Styles are a fixed list of properties and checked valuesproof

#Moving things

#Drag any block anywhere, and edits to it survive the moveproof

#Two moves of one block at once never duplicate or lose itproof

#Cut and paste within the page is a moveproof

#Components

#Insert any component from the libraryproof

#A component's settings are a form, made from its schemaproof

#A new component is made from existing onesproof

#Changing a component changes every copy, keeping each copy's changesproof

#Source↑ Why · Priya adds what only code can do, and stops being asked for words Priya reads what an edit really changed, as text.

#One button flips between the page and its sourceproof

#The source shows everyone's edits as they happenproof

#Editing the source edits the pageproof

#A real app↑ Why · Priya adds what only code can do, and stops being asked for words Priya's booking widget comes from the app's source, built like any code.↑ Why · Sam changes the café's page without waiting on anyone The booking form keeps taking bookings while Sam edits around it.

#Components with behaviour come from the app's sourceproof

#Nothing an edit writes ever runsproof

#New code takes a rebuildproof

#Code drafted in a doc runs only once its pull request mergesproof

#The page keeps working while you edit itproof

#Any page renders, however edits mergedproof

#An app is a component: built code, state in docsproof

#A schema change migrates contentproof

#Yours↑ Why · Sam changes the café's page without waiting on anyone Sam's page stays Sam's: in Sam's browser and files, with no server to trust.

#Versions↑ Why · A team gets a launch page ready together Nobody loses work: anything can be gone back to.

#Go back to any earlier versionproof

#A page is readable text in gitproof↑ Why · Priya adds what only code can do, and stops being asked for words Priya reviews a page's changes in the pull request already in use.

#Save a page as a file, and open it anywhereproof

#History is kept outside the doc tooproof

#An edit merged in git comes back as editsproof↑ Why · Priya adds what only code can do, and stops being asked for words Priya edits a page in git, and it merges with the live edits.

#Private and shared

#No server ever reads your pageproof↑ Why · Sam lets an AI help, and decides what it sees Sam can say what was sent and to whom, because nothing else leaves.

#A grant on one doc reaches no otherproof↑ Why · Sam lets an AI help, and decides what it sees An agent let into one doc can read nothing else.

#Only granted writers' edits are taken inproof↑ Why · A team gets a launch page ready together Only the team's edits reach the page; a reader can't push one.

#Relays never see an editproof

#Publishing

#Published pages are plain HTMLproof

#A markdown file opens and saves back byte for byteproof

#An edit changes only its own linesproof

#A file another program changed comes in as editsproof

#Saving never overwrites a change made on diskproof

#Tags the editor can't draw are kept, and edited as textproof

#A file on any of your machines opens in the editor and saves thereproof

#A file changed on its machine comes into the open editorproof

#Safe to change↑ Why · Sam lets an AI help, and decides what it sees An AI that could restyle the screen still can't make deny look like allow.↑ Why · Sam changes the café's page without waiting on anyone Whatever Sam changes, there's a way back to a page that works.

#Containment

#The shell can't be edited liveproof

#A pane reaches nothing outside its rectangleproof

#Asks are drawn only outside every paneproof

#Recovery

#The address names the shell's versionproof

#One chord can't be rebound or coveredproof

#A broken theme can't hide the shellproof

#A bad shell build boots the last good oneproof

#A change that could lock you out is a trialproof