Should I vibe code
Collaborative whiteboards for brainstorming, planning, and workshops
Fourteen people in a live workshop is not a feature called multiplayer. It is a distributed system with an audience.
?
Their verdict, the Individual price and the build-time estimate come from their entry, MIT-licensed. Checked 2026-08-05.
?
Our verdict, the regret score and everything below it. Editorial and unsponsored — nobody can pay to be moved.
The honest answer
why the verdict is what it is
Fork tldraw, bolt on Yjs, and you have an infinite canvas with live cursors before lunch — this is one of the categories where the demo is almost embarrassingly good. What you have not built is the workshop, and the workshop is what Lucidspark sells. Voting that counts once per participant including the guest with no account. A timer that reads the same number on fourteen screens. Breakout boards that split a group and merge the results back. Presentation mode that drags everyone's viewport somewhere. Guest links that let a client into one board and nothing else. Each of those is a small distributed-systems problem, and they all have to be right simultaneously, live, while a facilitator is talking. The failure mode is specific and unforgiving: a whiteboard that drops the last ninety seconds has not lost a file, it has lost the output of forty minutes of eleven people's time, in front of them, with no way to reconstruct what was on it.
What actually breaks
not "if". the specific failures.
- Persistence under load, which is the one that ruins a session: the CRDT is fine in memory and the write to durable storage is debounced, so a server restart during the busiest ninety seconds of the workshop takes exactly the part everybody was watching
- Presence and cursors, comfortable at four people and a message storm at thirty, because naive implementations broadcast every pointer move to every peer
- Undo in multiplayer, which is not a stack — undoing your own action after two other people moved the same sticky is a semantics question your library may have answered differently from your users
- Voting, which needs exactly one vote per participant including guests who have no account, and is trivially double-cast from a second tab
- The guest share link, which is an unauthenticated grant on a board that may have next quarter's org chart on it, forwarded into an email thread and fetched by whatever previews links in it
- Board size: a workshop that ends with nine hundred stickies and a canvas that no longer pans at sixty frames a second on the laptop the facilitator brought
- Export fidelity, because the board that opens as a flattened PNG in six months has lost the grouping, the links and the reasoning
- Version history on an infinite canvas, which is an append-only log that grows forever and is the first thing to make storage costs interesting
- Reconnection, where a laptop that slept through a coffee break has to resync a diverged document without helpfully deleting everyone else's changes
Is that you?
the verdict is a default, not a law
- It is a single-user canvas that syncs between your own devices and nobody is ever in it with you
- You are forking a mature canvas — tldraw or Excalidraw — and adding a sync backend you did not invent
- The board is a scratchpad rather than a record, and losing one costs a sigh
- Sessions are small, internal, and everyone in them can be told to refresh
- A facilitated workshop with a client in the room depends on it, which is the exact scenario the product exists for
- Share links have no expiry and no per-board scope, so a forwarded URL is a permanent read grant on strategy work
- Persistence is debounced in memory with no acknowledgement to the client — the user cannot tell saved from not-saved and will assume saved
- The board is the only record of a decision that other people believe was written down
If you build it anyway
the checklist, then the prompt that enforces it
- Build persistence and reconnection before you build a single drawing tool. Acknowledge writes to the client and show a real saved indicator; an optimistic UI over an unacknowledged write is how a session disappears.
- Use an established CRDT — Yjs or Automerge — and do not write your own merge semantics. This is a field with a literature and your intuition is wrong in interesting ways.
- Snapshot to durable storage on a wall-clock interval as well as on idle, so the busiest minute of the session is not the least-saved minute.
- Throttle presence separately from document updates, and send cursors over a lossy channel. Nobody needs guaranteed delivery of a mouse position.
- Make share links expire by default, scope them to one board, and show the board owner every link that exists with who has used it.
- Give guests identities that survive a refresh, or voting and attribution both quietly break in the middle of the exercise.
- Ship export to a structured format — JSON, SVG with grouping intact — before export to an image. An image is a screenshot, not a record.
- Load-test with more participants than you expect, because the whole product is the moment when everyone is in it at once.
I am building a collaborative whiteboard for live workshops: infinite canvas,
sticky notes, real-time cursors, voting, a timer, and guest access by link. The
failure I care about is losing work while people are watching. Order matters.
1. Do not invent a sync algorithm. Use Yjs or Automerge and tell me which
guarantees you are relying on. If I ask for a homegrown merge, refuse.
2. Build persistence and reconnection before any drawing tool: durable
snapshots on a wall-clock interval as well as on idle, plus a client-visible
saved indicator driven by a real server acknowledgement.
3. Write the reconnection test first — a client that sleeps for ten minutes and
rejoins must converge without deleting anyone else's work.
4. Separate presence from document state. Cursors and selections go over a
lossy, throttled channel; document updates go over the reliable one.
5. Guest access: links are scoped to one board, expire by default, and are
listed for the owner with usage. No link may grant edit rights unless I
explicitly ask, per link.
6. Give guests a stable identity that survives a refresh, and make voting
idempotent per identity. A second browser tab must not double a vote.
7. Undo is per-user and must be defined explicitly against concurrent edits.
Write down the chosen semantics in the README before implementing it.
8. Ship structured export — board JSON and SVG with grouping preserved — before
any image export, and before any styling work.
9. Cap or virtualise the canvas: tell me what happens at 1,000 objects and 30
participants, and load-test it rather than guessing.
10. Version history is append-only with a retention policy from the first
commit. Show me the storage growth per hour of active session.
11. Out of scope until I ask: breakout boards, AI clustering of stickies,
embedded Jira cards, and comments with notifications. Each is its own
project and none of them matters if the board loses the last two minutes.That one keeps you out of trouble. For the prompt that actually builds it, canivibecodeit.com has one.
their build prompt ↗Or don’t build it
the boring option, and the way back out
Buy it the first time a client is in the room. The subscription is per seat and small, and what it covers is the infrastructure that has to be right exactly when everyone is looking: persistence under concurrent load, presence at scale, guest access that works on someone else's corporate network, and a support number for the morning it does not. The homemade canvas is a genuinely lovely personal tool and a genuinely bad thing to run a facilitated session on.
Whiteboards leave badly unless you plan for it, because the board is the artefact and the format is bespoke. Export structured board JSON from the beginning and keep an SVG snapshot per session, so a migration to Miro, Lucidspark or a stack of Excalidraw files is a conversion script rather than fourteen people redoing an exercise from memory. If you built on tldraw or Excalidraw you inherit their file formats, which is genuinely the best exit available here — a `.excalidraw` file opens in a tool you do not maintain.
Infinite-canvas SDK with a polished interaction model and a documented sync story.
Open-source canvas with an approachable feel and a portable file format worth inheriting.
The CRDT most collaborative canvases end up standing on, so you do not have to invent merge semantics.
Questions
buildEase is 6.3 — higher than the seeded 4. Why?
Because the honest answer is that this is a fork, not a build. tldraw and Excalidraw are mature, well-documented canvases, Yjs is a mature CRDT, and an agent can wire them into a working multiplayer board in an afternoon. That is precisely what makes the entry worth writing: the easy path gets you 80% of a whiteboard and 0% of the persistence, guest-access and load behaviour that decide whether a live session survives.
How is this different from the Lucidchart entry?
Lucidchart is a diagramming tool where the artefact is a document you come back to, so its story is about shape libraries, layout and export fidelity. Lucidspark's artefact is a session — a group of people in the canvas at the same time, voting and timing and talking. That shifts the risk from "does the file still open" to "does it stay up and consistent for eleven people for forty minutes", which is a different engineering problem with a much less forgiving audience.
Is the guest link really a security issue?
It is the most common one in this category. A share link is a bearer token in a URL: it gets forwarded, pasted into a ticket, unfurled by a chat client and archived in an inbox that outlives the project. If it has no expiry and no board scope, the strategy board from a client workshop stays readable by anyone who ever saw the link. Expiry and per-board scoping cost an hour and remove the whole class of problem.
Every week, someone ships something they shouldn’t have.
New verdicts, the worst thing that landed in the trap, and the occasional incident report. No other email, ever.
A canvas is easy. A canvas forty people drag things around on simultaneously is a research project.
The canvas is MIT — take it. What Plus sells is the server that still has your boards on Monday.
Boxes and arrows is an afternoon. Arrows that stay attached when you move the box is a career.
last reviewed 2026-08-05 · verdict is editorial and unsponsored · shared entry data from canivibecodeit under MIT · not legal advice