Always the live product
Every screen is the running build, captured on real devices. When the product changes, the canvas already shows it.
NEW Optimize writes your sitemap, flows and design system
DesignSelected · live layer
DesignSelected · live layer
on the real product.
CRABZLAB puts your running product on an infinite canvas. Point at anything and it knows the component. Your own AI ships the fix.
The real editor on a real product: 17 routes of the Goldmarket app, captured on phone.
Lab results
Numbers,
Numbers,
not adjectives.
Measured on the same Mac as the old review board, with twelve live screens on the canvas. Point at a result to replay it.
First paint
34ms
from opening a file to a drawn canvas
Pan and zoom
16.8ms p95
with 12 live screens on the canvas
Devices
28presets
phones to 5K, with real pixel ratio, touch and user agent
Idle CPU
0.0% CPU
when nothing on the canvas moves
Tests
1,341passing
automated tests across 14 packages, run Sep 17
Why CRABZLAB
Your design file is a picture.
Your design file is a picture.
Your product moved on.
Design tools hold drawings, feedback tools hold screenshots, agents hold the repo. Nothing holds the product itself.
Pins name the component
Click the element. The note carries its name, route and box, so nobody has to guess which one you meant.
Your agent gets the exact element
Send to iterate writes a brief that names the element and the screen. Your own AI reads it, so the fix lands where you pointed.
How it works
From running product
From running product
to shipped fix.
Four steps on one canvas. Every step leaves something the next one uses.
One file, eight pages
Every way to look
Every way to look
at a product.
Routes, journeys, states, tokens and brand, side by side. All built from the same running product.
01 / 08
Every route, live.
Screens in view run as the real product, up to twelve at once, so menus open and forms validate. The rest are fresh captures.
- Zoom 5% to 400% under the cursor
- Sections by area, each screen with its route
- Capture age on every screen, one click to refresh
02 / 08
Journeys as real flowcharts.
Start, steps, decisions and routed arrows, generated from the product's own links. Every step is a route that exists.
- Built from the link graph
- Decisions where a form or state gates the path
- A real screen on every step
03 / 08
One row per person.
The same product walked by different people in different states, each row showing the screens that journey passes through.
- One journey per state the product supports
- Personas named by your own AI when allowed
- States captured as they are
04 / 08
The route tree, from the code.
Real routes grouped by area and ordered by depth from the entry. Routes without a screen show up in the health report.
- 17 routes in 4 areas for Goldmarket
- Levels and counts at a glance
- Stays in sync every time you run Optimize
05 / 08
The system the product actually uses.
Colours, type and components come out of the product's own tokens file and tags, not a separate style guide.
- Tokens read from tokens.ts
- Components from data-testid tags
- Unused tokens get flagged
06 / 08
Real devices, side by side.
Each preset carries its true pixel ratio, touch and user agent, so the layout is the one people actually get.
- 28 presets from phones to 5K
- Real pixel ratio and touch
- One click to capture them all
07 / 08
References next to the product.
Drop, paste or link pictures onto a moodboard in the same file, so direction and result sit one zoom apart.
- Drag, paste, URL or file
- Masonry that reflows as it grows
- Sticky notes for the why
08 / 08
The brand, checked against the product.
Logo on every ground and each colour pair with its WCAG ratio. When a pair fails, you see it before a user does.
- Contrast ratio on every pair
- Logo on light and dark
- Read straight from the tokens
Comments that know the code
Point at anything.
Point at anything.
CRABZLAB knows what it is.
Hover the live product and every element tells you its name. Click, and the comment carries the component, box and route a developer or an agent needs.
Optimize
One button turns screens
One button turns screens
into a documented product.
Optimize reads the product behind your screens and writes the pages that describe it. One step, and one Undo.
Reads
ts
app/src/app21 routes, 23 links
{ }
board.json17 captured screens
#
tokens.ts56 colours
</>
components.json59 components
Goldmarket
Writes
Sitemap21 routes in code
Flows4 journeys
Scenariosone per state
Design system56 colours
Organise17 screens, 4 areas
Context pack10 files
Tagging plan12 tasks
Health report89 findings
All pages written as one step. Your edits kept.
Structure first, offlineRoutes, links, tokens and tags come straight from the code. No network needed.
Your AI names, never invents In buildOnce connectors ship, your CLI names journeys. It cannot add a route that does not exist.
Safe to run twiceKeep my edits is on by default. A second run changes nothing.
Bring your own AI
Your AI. Your machine.
Your AI. Your machine.
Nothing proxied.
Send to iterate writes a precise brief into your repo. You run the coding agent you already use on it, and the screens catch up.
The CLI you already pay forClaude Code, Codex, Gemini CLI or OpenCode, signed in as you. No keys pasted into CRABZLAB.
A brief, not a guessEvery pin carries the component, its chain in the tree, its size and your note, plus which context chunk to read.
Status comes backYour agent marks each pin in STATUS.json as it goes: queued, planning, in progress, done.
In buildStarting your CLI from inside CRABZLAB, without a terminal.
Context pack
The map your AI reads
The map your AI reads
instead of the whole repo.
Optimize writes a small map of the product into your repo. The agent opens the index, then only the area it needs.
10 files, written from the codeTap files
What the agent readsGoldmarket
147x
less to read,
so fewer wrong guesses
so fewer wrong guesses
In your repoWritten under
review/context/, next to your code.One area, one promptChunked so a single area fits in one prompt.
Your edits stayNever overwrites a file you edited.
Everywhere you work
One canvas,
One canvas,
on every screen.
The desktop app and the web app are the same code, so the canvas, pins and pages behave the same. macOS runs today as a preview build. Tablets come next.
Honest comparison
Why not just use
Why not just use
what you already have?
Each category does one part well, and we mark where it leads. CRABZLAB puts the parts around your running product, on one canvas.
CRABZLAB vs
Capability
Design toolsDrawing, prototypes, and capturing a running UI into frames
Feedback widgetsPins on a live website that turn into tasks
Code-side editorsVisual edits on a live React app, written back to code
Component reviewVisual review of real components, with comments
Coding agentsChanging the code, with toolbars to point at the page
CRABZLABThe running product, reviewed and fixed on one canvas
Shows the running product, not a picture
Design tools: Partly. Captures it into frames
Feedback widgets: Yes. Pins sit on the live site
Code-side editors: Yes. Live, React apps only
Component review: Partly. Components, not whole pages
Coding agents: Partly. Your localhost, through a toolbar
CRABZLAB: Yes. Live, up to 12 screens at once
Every screen on every device, side by side
Design tools: Partly. Frames you place by hand
Feedback widgets: No. One page at a time
Code-side editors: Partly. Pages on one canvas
Component review: No. One component at a time
Coding agents: No. The tab you have open
CRABZLAB: Yes. 28 device presets, phone to ultrawide
Flows, scenarios and sitemap
Design tools: Partly. Drawn and kept up by hand
Feedback widgets: No.
Code-side editors: No. No scenarios
Component review: No.
Coding agents: No.
CRABZLAB: Yes. Generated from your routes and links
A comment that knows the component
Design tools: No. Pinned to a spot on a frame
Feedback widgets: Partly. The page and a spot on it
Code-side editors: Partly. The element, not your own tags
Component review: Yes. On the component itself
Coding agents: Yes. The element you point at
CRABZLAB: Yes. Name from your tags, box and route
Review status from draft to tested
Design tools: Partly. Threads you resolve
Feedback widgets: Yes. Pins become tasks
Code-side editors: No. No team review flow
Component review: Yes. Built for visual review
Coding agents: No. Annotation only
CRABZLAB: Yes. Draft to Tested on every pin
An AI that changes your code
Design tools: Yes. Its own AI opens pull requests
Feedback widgets: No. Tasks for people
Code-side editors: Yes. AI chat, written to code
Component review: No.
Coding agents: Yes. That is the whole job
CRABZLAB: Partly. Writes the brief for your own CLIin-app run in build
Vector drawing from scratch
Design tools: Yes. Their core, and they lead hereleads
Feedback widgets: No.
Code-side editors: No. Edits existing UI
Component review: No.
Coding agents: No.
CRABZLAB: No. Not yet, on the roadmaplater
Where CRABZLAB is not there yet
Accounts and sharingIn build
Reviewing one file with teammates across accounts and devices.
Windows, Linux and webIn build
macOS 0.2.9 is a preview build today. The others run the same code and are in build.
Public URLsLimit
A URL gives captures of every screen. Live frames and component names need a local build.
Categories, not products. Our reading of each one, checked on 16 September 2026. Tools move fast.
Roadmap
Ten builds shipped.
Ten builds shipped.
Create and fine-tune next.
Every macOS build since Sep 16, with what changed. Reviewing the running product works today. Creating on the same canvas comes in the phases after it.
Commits per hour from the repository history, times in UTC+4. Each tick is a release, and 0.2.1 and 0.2.2 share one, a minute apart.
1
In build
Review native
The fine-tune half: review the running product, comment, iterate with your AI.
Shipped in 0.2.94 of 8
- Canvas of live frames and captures, 28 device presets
- Screens, flows, scenarios, sitemap and design pages
- Comments that are pins, from Draft to Tested
- Optimize and the context pack
- Run your own CLI and MCP from the apptoday the app writes the brief your CLI works from
- Web app from the same code
- Windows and Linux builds
- Sign in, sync and sharingtoday the app says
Local, not signed in
Exit gateWe review our own products, Goldmarket among them, in CRABZLAB instead of the board it grew out of.
After that
- 1bTablets Next
iPad and Android tablet from the same web bundle. Pinch, two-finger pan, long-press to comment, panels as sheets.
Exit: comment a file on iPad with Pencil while it is live on desktop.
- 2Record and tag
Record scenarios from the live frame, a redline overlay, onboarding that tags your app.
- 3Create the create half
Image, video and asset generation on the canvas, a brand kit per product, credits metered.
- 4Fork and proposal
A live page becomes layers, a change becomes a code proposal, CSS applies live.
- 5Styles and components editor
- 6Vector editor
- 7Scale
Present mode, plugins, WebGPU, billing.
Phases from the product's roadmap doc, revised Sep 16, 2026.
Planned pricing
Priced by the fixes
Priced by the fixes
you ship.
Every plan opens the whole tool: the live canvas, all eight pages, pins and Optimize. Plans differ by iterate runs, projects and seats.
Planned. Billing ships in phase 7 of the roadmap.
One person with a few products.
$20per month
Iterate runs25 a month
- 3 projects
- Live canvas, eight pages, pins and Optimize
- Your own AI CLI and MCP connectors
People who ship every week.
$100per month
Iterate runs150 a month
- Unlimited projects
- Priority support
- Everything in Starter
Small teams and agencies.
$200per month
Iterate runs400 a month
- 5 seats
- Everything in Pro, under fair use
What counts as a run
One Send to iterate
One Send to iterate
is one run.
It does not matter how many comments or screens it carries. They all travel in the same brief.
- 1You press Send to iterateEvery draft comment in the file goes out together. A draft with no comment stays behind.
- 2CRABZLAB writes the brief
LATEST.md,STATUS.jsonand a crop per pin, under one timestamp. - 3Your AI CLI works through itEach item moves from queued to done in
STATUS.json. The bar checks it every 5 seconds. - 4The screens are captured againYou review the changed product, then send the next round.
General11 general note/catalog32 pins, 1 screen note. The pin with no comment is left out./product/12322 pins/store/product/new21 pin, 1 screen note
Each item in
STATUS.json moves through
queuedplanningin progressdoneskippedneeds info
8items in
71 lines, 4,658 bytes
LATEST.md71 lines, 4,658 bytes
1Runs usedrun
1 of 150 on Pro
1 of 150 on Pro
From the iterate package's test run: 3 screens, 6 pins with one left blank, 2 screen notes and 1 general note.
$0.75for each run past your plan's monthly runs.
Cost + 20%for image and video generation credits, metered on top once Create ships.
Your AI stays yoursThe brief goes to your own AI CLI, on your machine. Running it from inside the app is in build.
FAQ
Questions people
Questions people
ask first.
Setup, your data and how the loop works. Where macOS 0.2.9 stops short today, the answer says so.
Getting started
3 questionsWhat do I need to start?
A Mac with Apple silicon on macOS 13 or later, and your product: a web build in a folder, or its public URL. Captures run in a Chromium-family browser. If none is installed, CRABZLAB downloads Chrome for Testing into its own folder on the first capture. The fix loop also needs one AI CLI, signed in as you.
What can I connect?
A web build that CRABZLAB serves from a folder on your machine, such as an Expo web export or plain static HTML. A public URL works too, with one limit: CRABZLAB cannot inject its agent into a site it does not serve, so a live site gets captures and no live frames.
| Feature | Local build | Public URL |
|---|---|---|
| Captures of every screen | Yes | Yes |
| Live, clickable frames | Yes | No |
| Pins that name the component | Yes | No |
Do I have to change my product's code?
No. Captures, live frames and pins work on the build as it is. An untagged element is still pinned with its selector, box and styles, under a guessed name like ? primary button. Add data-testid="Button:primary" and the pin carries the real component name. Optimize writes a tagging plan that ranks the elements still missing a tag by how often pins land on them.
How it works
3 questionsHow does CRABZLAB know which component I clicked?
When CRABZLAB serves your build it injects a small script, agent.js, into the live screen. It reads the element under the cursor: its selector, box, styles matched to your design tokens, and the component name from the nearest data-testid tag, with the chain of tagged parents above it.
What is an iterate run?
One press of Send to iterate. Every draft comment that has text goes into one brief, LATEST.md, grouped by screen, with each pin's component, selector and box. STATUS.json tracks every pin while your agent works through them. A draft with no text is left out.
- Draft
- Queued
- Planning
- In progress
- Done
- Tested
Does it replace my design tool?
Not for drawing from scratch, yet. Today CRABZLAB is where you see, review and fix the running product and map its structure: screens, flows, sitemap and design tokens. A styles and components editor and then a vector editor are on the roadmap, on the same canvas.
Your code and data
3 questionsDoes my code leave my machine?
Not in the desktop app. In 0.2.9, Send to iterate writes the brief, LATEST.md and STATUS.json, on your Mac for the AI CLI you run yourself, with your own subscription. Running that CLI from inside CRABZLAB is in build, and it stays on your machine: nothing is proxied. The web app, also in build, takes captures on a CRABZLAB frames server.
Where do my files, comments and captures live?
On your machine, for now. Files and comment threads are saved in the app's local storage. Captures are PNG files in the app cache, one folder per product, cleared when the product's build changes. Accounts and sharing across devices are in build now, in phase 1.
Which AI agents work with it?
In 0.2.9 you run your own AI CLI on the brief, LATEST.md. The connectors in build know Claude Code, Codex CLI, Gemini CLI and OpenCode. They find each one on your PATH, give it a role (Iterate, Images or Research) and add MCP servers by command or URL.
Platforms and language
3 questionsWindows, Linux or a tablet?
macOS runs today as the 0.2.9 preview build. Windows, Linux and the web app are in build from the same code. Tablets come next as the web app installed on the device: touch and pencil first, for review and comments.
- macOSpreview
- Windowsin build
- Linuxin build
- Webin build
- iPadnext
- Android tabletnext
Which languages does it speak?
English and ქართული. Every interface string exists in both, and you switch in Settings. Components can carry aliases in both languages, and they show on pins and in Inspect.
Why the name CRABZLAB?
Short for Crazy Businessman Lab. It started as the review board for our own products, Goldmarket first, and grew into a tool of its own.
macOS 0.2.9 preview build
Stop reviewing picturesSelected · picture
Stop reviewing picturesSelected · picture
of your product.
Open the real thing, point at what matters, and let your own AI ship the fix.
macOS 0.2.9 preview buildApple siliconmacOS 13 or laterNo public download yet