Platform
Live preview for serious AI software delivery
The application runs live beside the chat while it is built — real flows, real clicks — and preview links let stakeholders see it before anything ships.
Live preview is the running application beside the chat in the Ciao Builder: as the AI builds, the real app updates and responds to real clicks. Unlike tools where you deploy to discover what you got, live preview shows every change the moment it lands, powers inspect-to-prompt targeting, and generates shareable preview links so stakeholders review the actual app before it is published.
Published 2026-07-03 · Last updated 2026-07-03
Never build blind
The oldest failure mode in software delivery is distance: weeks pass between the request and the demo, and the result is wrong in ways that would have taken thirty seconds to catch on day one. AI compresses the timeline, but it can make the blindness worse — code now appears faster than anyone can read it, and a wrong assumption compounds at machine speed.
Ciao closes the distance to zero. The application runs live beside the chat while it is built. Not a mockup, not a screenshot — the real app, on real data structures, responding to real clicks. When something is off, you see it now, while the context is still fresh and the fix is one prompt away.
The preview is also the anchor for the Builder's other habits: inspect-to-prompt uses it as a shared frame of reference, queued prompts are reviewed against it as they land, and the full-stack console explains what it is doing under the surface.
How live preview works
From first prompt to publish, the preview is the constant — the thing everyone is looking at while decisions get made.
1. Describe, and watch it appear
As the Builder works, the app takes shape in the preview pane beside the conversation. Progress is visible, not promised.
2. Click through real flows
Sign in, create a record, run the search, submit the form. The preview is the working application, so testing starts the minute building does.
3. Point at what to change next
Live preview powers inspect-to-prompt: click any element in the running app to reference it in your next prompt.
4. Share a preview link
Send stakeholders a link to the running app before anything is published. Feedback arrives against the real thing, not a slide deck.
5. Pass the gates
When you publish, QA runs deterministic browser replays and smoke gates first, then production checks after — the preview is where you catch intent problems before the gates catch defects.
6. Publish deliberately
Preview and production are separate. Nothing reaches users until you choose to ship it.
Why it matters
Feedback cost determines build quality. When seeing a change costs a deploy cycle, people batch their doubts and discover problems late; when it costs a glance, every assumption gets checked while it is still cheap to fix. Live preview collapses the price of verification to near zero.
It also changes stakeholder review from a meeting into a link. Clients, executives and end users react to the running app days before launch — which is precisely when their opinions are still affordable to act on.
There is a governance benefit hiding inside the convenience, too: people approve what they have actually seen running. Sign-off against a live application means fewer launch-day surprises and cleaner accountability when someone later asks who reviewed this.
Who uses live preview
Live preview is the least specialized feature on the platform — everyone with a stake in the app ends up in it:
- Founders — Validate product decisions against the running app in real time instead of imagining how it will feel.
- Agencies — Send clients preview links mid-project — fewer surprise reveals, faster sign-off, calmer launches.
- Product managers — Demo the actual application to stakeholders before publish and fold their reactions into the prompt queue.
- Operations teams — Have the people who will use the tool click through it before it ships to them.
Security and governance notes
Seeing early does not mean shipping loosely:
- ✓ Preview and production are separate — publishing is a deliberate, gated action.
- ✓ QA smoke gates run before publish and production checks run after, regardless of how good the preview looked.
- ✓ Changes behind the preview live on real git branches with diffs and checkpoints.
- ✓ Guardrails policy review and recorded human review stand between preview and merge.
- ✓ Publishes and deploys are recorded in the append-only audit trail.
Deploy-to-see vs live preview
The workflow difference compounds over the life of a project:
| Deploy-to-see workflow | Ciao live preview | |
|---|---|---|
| Time to see a change | After a build-and-deploy cycle | Immediately, beside the chat |
| Stakeholder feedback | Meetings, screenshots, staging access requests | A preview link to the running app |
| Cost of a wrong assumption | Compounds until someone deploys and notices | Caught while the context is fresh |
| Directing the next change | Described from memory | Pointed at directly with inspect-to-prompt |
| Publish decision | Entangled with seeing the result | Separate, deliberate and gated |
Frequently asked questions
Is the live preview the real application or a simulation?
The real application. It is the generated React, TypeScript and Supabase app running live, which is why you can click through actual flows and why inspect-to-prompt can resolve what you click to real components.
Can people outside the build see the preview?
Yes — preview links are made for exactly that. Clients and stakeholders review the running app before publish, so feedback happens against reality rather than a mockup.
Does anything in the preview affect production?
No. Preview and production are separate, and publishing is a deliberate step gated by QA smoke gates. Until you publish, users see nothing.
What happens between preview and publish?
The change merges under Guardrails with recorded human review, QA runs deterministic browser replays and smoke gates before publish, and production checks run after. The preview is where you fix intent; the gates are where defects get caught.
Is live preview part of the standard Builder?
Yes — the app running beside the chat is how the Builder works, and individual builders start self-serve with credits. Serious production programs start at USD 10,000 per year.