Tutorials

Most AI tutorials spend you before they teach you. Install this, copy that, paste in a key, wire up a service, and somewhere past the setup there is supposed to be a result. Plenty of people never get to see it.

Every tutorial here is a flow that already ships inside the app. Nothing to install, nothing to paste: open the flow, run it once, and read what it did.

The written walkthroughs are still being recorded. The flows below are live today.

SpacePaperschat, the command surfacedraft the methods sectionwriting to main.tex, thencompiling, 1 approval needed/papersask, or slash a flowsidecar: the source, the log, the PDFpreviewcompile log0 errorsthe run that worked can be saved as a flowflow.jsonevery flow is also a tool the Sim can call
Most flows work like this: the chat is the command surface, the sidecar holds the thing being made, and the run that worked can be saved.

01

Write a paper with the compiler running beside you.

Papers puts the conversation on the left and the document on the right: source, compile log and rendered output in a sidecar that stays open while you work. You ask for a section, the flow writes to the file, the compile result comes back in the same view. Writes that persist stop and ask first, so the document never changes behind your back.

01you askdraft the methods section02it writesmain.tex changes on disk03you approvethe write is protected, so it asks04it compileslog and PDF land in the sidecar05you readthe paper, not a transcript about itThe loop is short on purpose: every step is visible before the next one starts.
Short on purpose: every step is visible before the next one starts.
  • Ask for a section, get a file.
  • Watch the compile as it runs.
  • Approve the writes that stick.

02

Cut a reel from photos, narration and music.

Reel Machine takes the images you point at, a voice track and a piece of music, and returns a cut. Around it sit the smaller media flows you will reach for on their own: generate an image from a prompt, render frames on the machine, apply a transition between two clips, animate a still into a short video. Media work is where the local lane earns its place. The machine renders, and nothing has to leave it.

you point ata folder of photographsa voice tracka piece of musicReel Machinepicks, orders and cutsagainst the narrationand the beatyou geta cut, in the Spacethat produced itand re-runnableThe smaller media flows are useful on their own:/image/anime/transition/dr-vid/axeLocal-first renders on the machine, so the source material never has to leave it.
One flow that assembles, and several that do one thing well enough to reach for alone.
  • Point at the folder, not at a file list.
  • Render on the machine when local is enough.
  • Keep the output in the Space that made it.

03

Pull the outside world into a Space.

Scrape a page into the Space it belongs to. Download an authenticated board into the local sandbox. Search your own mailbox and get patterns back instead of a wall of threads. Each of these lands as files inside a Space, where every other flow can already reach them.

a web page/scrapetext and assets, as filesan authenticated board/pinterest-board-downloadthe images, into the sandboxyour own mailbox/mail-search-analyticspatterns, not a wall of threadsEverything lands inside a Space, where every other flow can already reach it, and credentials stay on the Mac.
Each arrives as files, in the Space that asked for them, already searchable.
  • The web arrives as files, not as a preview.
  • Credentials stay on the machine.
  • What arrives is searchable immediately.

04

Let the builder build the flow.

Build designs, assembles, tests and publishes new flows through conversation. You describe the outcome; it composes atoms that already exist in the registry, runs the result, and publishes it once it works. A published flow is also a tool, so the Sim can call it the next time the same job shows up.

describethe outcome you want,in one sentencecomposeatoms already sittingin the registryrunagainst real inputs,oncepublishonly what actuallyworkedand the published flow becomes another atom for the next one to composeBuild is itself a flow. gOS designs, assembles, tests and publishes flows through conversation,which is why the catalogue grows without the app being rebuilt.
The output of the last step is an input to the first one, which is how the catalogue grows.
  • Start from the outcome, not the graph.
  • Reuse the atoms that already exist.
  • Publish only what actually ran.

The fastest way to understand gOS is to run one flow end to end and read the trace it leaves behind.