Capabilities

The platform in full

105 capabilities across the nine areas of work VibeSharing supports, from getting a prototype live through to administering the team around it. Every one of them is available today.

Only on VibeSharingmarks the 11 capabilities with no equivalent in another tool.

Getting it live

From whatever you built it in, to a URL you can send

Deploy from your editorOnly on VibeSharing: An MCP server for Claude Code, Cursor, and any MCP client. Ask it to share what you just built and it deploys, without you leaving the conversation you built it in.
Deploy from the command line: npx vibesharing deploy pushes the current directory. Log in once with a deploy token, link a prototype, and every deploy after that is one command.
Import a GitHub repo: Point at an existing repo and it becomes a prototype with a live URL. Re-importing reuses the same hosting project rather than piling up duplicates.
Push a single HTML file: One file, one function call, one URL. For the times a prototype is a page, not a project.
Upload a ZIP: Drag a folder in from the dashboard when there's no repo and no editor in the loop.
Push to deploy: Push to main and the prototype rebuilds on its own. No second command, no dashboard visit.
Three prototypes hosted on us: Sign up and deploy with no hosting account, no token, and no card. They stay live for good — nothing expires and there's nothing to cancel.
Redeploys never count: The three counts distinct prototypes, not deploys. Ship it, gather feedback, ship it again — the loop is always free.
Bring your own hosting: Add a Vercel or Netlify token and the limit disappears. Prototypes deploy to your infrastructure, under your account, on your bill.
Enterprise infrastructure: Per-organization GitHub org, deploy provider, credentials, and custom prototype domains — configured by an infrastructure admin, separate from who manages people.
Pre-deploy validation: Catches duplicate config files, conflicting output settings, a missing framework, committed build artifacts, and case-sensitive path mismatches before the build runs.
Deploy errors in plain language: What broke, what to try, a Copy for AI button to paste straight into your assistant, and one click to send it to us if it's ours.
Diagnose: Ask from your editor and it walks a broken deploy, a blank page, or a permission error and reports what it found.
Build status without polling: The live build state is readable from the dashboard and from MCP, with the build output attached when it fails.

Making it look like your product

Your design system, applied before the first line is written

Design system templates: Your organization's tokens, typography, and component conventions, stored as a template and applied at deploy time.
On-brand from the first promptOnly on VibeSharing: Describe what you want and your AI client picks the right template, receives its CSS and design instructions, and generates code that's already on your system — instead of building generic and retrofitting.
Design instructions, not just tokens: Each template carries written guidance for the AI reading it — how the system wants things laid out, not only what color they are.
Reference screenshots: Upload a picture of what the template should produce. The AI uses it as a visual target while it builds.
Base templates and variants: Build one structural foundation, then spin up color variants off it. Update the base and every variant inherits the change.
Anyone can make one: Templates live in the main navigation and any member can create and edit them — design system work isn't gated behind an admin role.
Name-or-slug lookup: my-template, my-template-abc12345, and My Template all resolve to the same template, in deploys and in the dashboard.
Color preview and attribution: Each template card shows resolved color swatches, who added it, and who last edited it — so a mystery template is traceable.
Browse templates from your editor: List what your organization has and pull a specific one down without switching to the browser.

Hearing back

Responses attached to the thing they're about

Comments pinned on the UIOnly on VibeSharing: Reviewers drop a pin on the exact element they mean and write underneath it. No screenshots pasted into Slack, no describing where the button is.
A screenshot with every pinOnly on VibeSharing: Captured automatically at the moment of the comment, so you see what they saw — including the state they were in when it bothered them.
Page-aware pins: Pins belong to the page they were left on. A tray shows per-page counts, and selecting a pin navigates the prototype to its page.
Threaded replies: Conversations happen under the comment instead of forking into three channels.
Scoped mentions: Mention autocomplete suggests the people already involved with that prototype — its owner, its followers, and anyone who's commented — not the whole organization.
Guided questions: Set what you want looked at before anyone arrives. Reviewers see your prompts instead of an empty comment box.
Questions drafted for you: Say what you built and what you're unsure about, and you get a handful of specific questions for your reviewers to answer.
Feedback focus at deploy: Each deploy can carry what to review and what to ignore, which turns shipping into a deliberate ready-for-eyes moment rather than a silent update.
Ask about this prototypeOnly on VibeSharing: Reviewers ask a question in the viewer and get an answer drawn from the project's docs, its deploy history, and the feedback already left — so small questions don't become your inbox.
Auto-classified feedback: New feedback is sorted by theme, priority, and whether it's actionable, so you get structured input rather than a raw list.
Triage: Filter by status, priority, and assignee. Assign in bulk, write resolution notes, and work the queue down.
Assignee picker that knows the context: Whoever deployed it first, then the people watching, then a search field for everyone else — instead of an alphabetical sprawl.
Watch a project, watch everything in it: Following a project follows every prototype inside it, including the ones added later.
Notifications that say something: Deploy notices name who deployed and summarize what changed. Delivered in-app and by email, with per-person email preferences.
One place for what's yours: My Work and Reviews collect the prototypes you own and the feedback waiting on you, across every collection.

Doing something about it

From a comment to a shipped change, and back to the person who asked

Review feedback by personOnly on VibeSharing: Ask your editor for the feedback and it answers with people, not a wall of text — grouped by who left it, with open and closed counts, so you start with whoever you most need to hear from.
Every comment arrives whole: The page it was left on, the exact spot, the screenshot, the rating or option chosen, the question it was answering, and every reply underneath it.
Build it, skip it, or talk it through: Decide per comment. Skipping writes nothing, so it stays open for later.
The change gets drafted for you: Choose build and your editor reads the code that comment points at and proposes the edit. Nothing changes until you approve it.
The person who asked finds outOnly on VibeSharing: Approving marks their comment in progress. Deploying tells them what you did about it — or that you decided not to, which is also an answer.
Every deploy is a version: Numbered, with a file manifest and git metadata, and its own immutable URL. Open v3 and you see v3, not the latest.
Per-version changelogs: What changed in each deploy, generated from the diff or written by whoever shipped it, shown on the share page as a What's New banner.
Version labels: Tag a deploy with a short name like dark theme variant so the history reads as decisions rather than numbers.
Fork: Copy a prototype to its own URL and explore freely. The original is untouched.
Rollback: Restore any previous version in one step, for git-based and static prototypes alike.

Testing with customers

Structured research on the real thing, not a deck about it

Studies: Turn a shared prototype into structured research: what you're testing, the questions you want answered, who gets in, and results that roll up. A single customer review is a study of one.
Blind, randomized comparisonOnly on VibeSharing: Each participant sees the prototypes in their own stable random order, labeled Option A/B/C with the real names hidden — so a label like v2 can't tip a preference test. Your side always shows which letter is which.
A builder you can move around in: Details, prototypes, questions, participants, and results as focused steps you can jump between in any order — not a linear wizard.
Questions you compose: A 1–5 star rating, a single- or multi-select choice with an optional write-in, a free comment, or any combination on the same question.
A starter question bank: First impressions, ease of use, comprehension, desirability, trust, comparison, priorities. Add one and edit it, instead of starting blank.
Per-prototype questions: When you're comparing several, give one its own questions. Otherwise it inherits the study's.
Two ways in: A shared password anyone with the link can use, or a named list where only invited addresses can take part.
Anyone with the link: A lighter mode with no password that still captures who responded by name and email.
You decide when it goes out: Studies are created as drafts. Opening one — which applies the gate and invites your people — stays a deliberate step, never a side effect.
A clean participant experience: A short brief, then the real prototype full-screen with none of our chrome, then your questions. The prototype stays one click away while they answer.
Results per question: Average rating with the full 1–5 distribution, choice tallies with percentages, and every comment in one place — one click from the study list.
Test something you didn't build here: Point a study at an external URL and run the same brief, questions, and rollup against it.
Set one up from your editor: One call bundles several prototypes, their briefs, and their questions into a draft study you review and open from the dashboard.

Checking your work

Whether the prototype is actually on your design system

InspectOnly on VibeSharing: Click any element in a shared prototype and read the design tokens wired to it, resolved to their live values. It reads the running code an engineer ships, not a picture of it — so hover, focus, and active states are right too.
Token name and value together: The stylesheet tells you which token was referenced; the live cascade tells you what it resolved to on that element. A computed-style read loses the name, a design file loses the value.
Handoff detail you can copy: The component the element resolves to, its wired tokens as property → token → value, and the key computed CSS, each copyable.
SuspectOnly on VibeSharing: Scan the whole screen for a Coverage score: of the mappable pieces on it, how many use a real component versus a hand-rolled one.
Off-system pieces, outlined: Each suspect is flagged on the prototype and listed with the role it's filling and the component that already exists for it. Click one to scroll straight to it.
Any design system: Driven by a small profile — which token prefix marks the system, which class signatures identify a component — rather than being tied to one library.
No redeploy, no setup: It rides the layer already present in every deployed prototype, so work you shipped months ago becomes inspectable the next time it loads.
Off until you want it: Inert behind a toggle, guarded so it can't touch the prototype's own behavior, and hidden from guided reviewers — it's a builder's tool.

Handing it off

So the next person picks up clean

Source stored with the prototype: The code that produced a deploy stays attached to it, with consent asked for up front rather than assumed.
Read the code in the browser: A source viewer on the prototype page, for the reviewer who wants to look without cloning anything.
Export and clone: Download the source as a ZIP, or take the clone instructions for the repo behind it.
Context links: Attach the Figma file, the doc, the ticket — whatever explains why this exists — to the prototype instead of to a thread.
Project context that stays current: Your CLAUDE.md or equivalent syncs on deploy, so the next person's AI client starts with what the last person knew.
A timeline of what happened: Deploys, context changes, and feedback in sequence on the project page, so picking up mid-stream doesn't require asking around.
Deploy diff summaries: A readable account of what changed between versions, in notifications, in the editor response, and on the project page.

Running your team

People, organization, and the record of what happened

Four roles: Member does the creative work. Admin manages people and settings. Infra Admin owns deployment configuration and credentials. Account Owner has all of it.
Invite by email: Invitees land in your organization after signing up, with the invite waiting rather than lost.
Bulk invite: Paste a list of addresses, or upload a CSV with names and teams. Teams that don't exist yet get created.
Join links: A link or code that puts people in the right organization without an individual invite for each one.
Domain auto-join: Anyone with a verified address on your domain joins automatically — verification required, so the domain can't be spoofed into your workspace.
Teams: Group people so a prototype can go to the governance team rather than to seven names you had to remember.
Google sign-in: Sign in with Google, no password to set or reset.
Your branding: Your logo and organization identity on the surfaces your stakeholders see.
Collections, projects, folders, and tags: Four ways to organize that hold up past the first fifty prototypes, with drag-to-move and bulk actions.
Search: Full-text across prototypes, projects, and collections, scoped to what you're actually allowed to see.
A dashboard sorted by what moved: Most recent activity first, with deploys and feedback both counting as activity — so the top of the page is the live work.
Usage analytics: Who's deploying, which AI tools your team actually reaches for, and how activity trends over time.
Interaction analytics: Exports, downloads, shares, source views, and feedback panel opens — how prototypes get used after you send them.
Audit log: Logins, project access, and feedback events recorded with who and when.
Legal acceptance tracking: Terms, Privacy Policy, and DPA with versioned acceptance. New signups accept before they get an account; existing users are prompted when a version changes.
Tenant isolation: Organization boundaries enforced at the database level and audited, so one workspace's data can't be reached from another.
Support without a ticket portal: Send a help request, bug report, or suggestion from inside the product — from the dashboard or from your editor.

Bring your prototypes home.

Five minutes from sign-up to your first deployed prototype. The first three are hosted on us.

Start sharing What's on which plan