withvibe
Sign in
Back home
Use cases

How real teams use a shared env.

PM shipsa featureMaya · PM40-person startup"Resend invite" button1spin envone click → repo clonedcontainer + dev serverisolated · never her machine2vibe with AI“add resend invite btn —only for pending members”AI edits page + API route→ preview live3pull in Adislack ping w/ env link“use useInvite() hook”AI refactorsMaya still drives4commit & PR+ TeamPage.tsx+ api/invites/resend.ts~ useInvite.tsPR #482 → main5agents gatesecurity ✓ code-rev ✓test ✓ policy ✓→ merge ✓all green→ shipped before lunch ✨
Env lifecycleAI chatLive previewShare envGit panelAgent gate

How real teams use a shared AI development environment

PM ships a feature, end to end (Product)

Maya is a PM at a 40-person startup. The team page needs a 'Resend invite' button. Before WithVibe she'd file a ticket and wait. Today she opens an env.

  1. Spin a fresh env from main. One click in the dashboard. The repo is cloned, container starts, dev server boots — all isolated to this env. Maya never touches her machine.
  2. Vibe with the AI. Maya types: 'Add a Resend invite button to the team page — only for pending members.' The AI edits the team page and the API route, restarts the dev server. The Preview shows the change live.
  3. Pull an engineer in. Maya pings Adi in Slack with the env link. Adi joins the same chat session, types: 'use the existing useInvite() hook instead of fetching directly.' The AI refactors. Maya still drives.
  4. Commit and open a PR. Git panel shows the diff across the touched files. AI proposes a commit message. Maya hits Commit & push. PR #482 opens against main.
  5. Agents run the gate. Security, code-review, test, and policy agents run on the PR. All green. Engineering merges. Maya shipped a feature before lunch.

Outcome: Feature in main without an engineer touching a keyboard.

Engineer pairs in VSCode, locally (Engineering)

Adi picks up Maya's env to handle the trickier edge case. He wants his full local IDE — debugger, jump-to-def, the works — not a chat box.

  1. Open the env in local VSCode. Click VSCode → 'Open on your computer'. A tunnel comes up, his local VSCode opens, files are the env's files. Same shell. Same node_modules. Same .env.
  2. Real IDE work. Adi sets a breakpoint, steps through the resend flow, finds the edge case (race condition when the invite is already expired). Fixes it in his editor.
  3. Run the suite in the env's terminal. Terminal panel inside the web UI: pnpm test team. Twelve passing. Adi adds a regression test for the expired-invite path.
  4. AI keeps the conversation context. Adi switches back to the chat tab and types: 'Update the docs for handleResend, I changed the signature.' The AI knows what changed because it's the same env.
  5. Push without ceremony. Git panel — stage, commit, push. PR updates. Adi closes the lid.

Outcome: Power-user dev workflow inside a shared env. Nothing leaves the env unless he pushes.

Sales runs a per-prospect demo (Sales)

Ben is doing a 3pm call with Acme. He wants to demo the unreleased 'audit log' feature with Acme-flavoured data — without booking eng time or fighting over staging.

  1. Env from the audit-log branch. Pick the audit-log branch, click create. A clean env spins up with the unreleased feature live.
  2. Seed it with Acme-shaped data. Chat: 'Load 90 days of demo data, with Acme's logo and team names from this CSV.' The AI runs the seed script in the Terminal and confirms.
  3. Tweak the demo on the fly. Five minutes before the call: 'Change the chart accent to Acme's brand blue, hide the experimental beta badge.' AI edits CSS, container reloads, Preview confirms.
  4. Share the live link in the call. Ben drops the env URL in the Acme Zoom chat. The product is running right there — not a screenshot, not a Loom. The buyer clicks around themselves.
  5. Leave it running for follow-up. Env stays up for 7 days. Acme's champion shows their VP at home that night. Same URL.

Outcome: Branded, pre-release demo without a single eng ticket.

QA tests with the AI-driven browser (QA)

Ron, QA lead, picks up the PR Maya opened. He doesn't want to click through every team-page combination by hand.

  1. Open the QA Browser. Sidecar mode boots a headless browser inside the env, navigates to /team. Ron sees the live page in the panel.
  2. Hand the test plan to the AI. Chat: 'Click Resend on every pending member, confirm the toast appears, then dismiss it. Screenshot each step.' The AI drives — click, wait, screenshot — and posts back a step log.
  3. Find a regression. On the third row the toast doesn't dismiss. The AI flags it, attaches the screenshot. Ron creates a ticket from chat with the env link pinned.
  4. AI fixes in the same env. Chat: 'Fix the toast state reset, add a regression test for multi-row dismissal.' AI edits, restarts, tests pass.
  5. Re-run QA, then ship. Ron asks the AI to re-run the QA plan. Green. Agent gate re-runs on the PR. Merged.

Outcome: End-to-end QA, AI-driven, against the exact code the dev wrote.

Co-design a feature with a customer, live (Customer success)

Acme's CTO wants a custom retention report. Yael (CSM) sets up an env and invites her into a working session — not a slide deck.

  1. Env from the reports module. Yael creates an env off the reports-v2 branch. The data warehouse connection is already configured in the env's compose.
  2. Invite the customer to the env. Share link. Acme's CTO joins the same chat session. She sees Yael's cursor and chat messages live.
  3. Shape the report together. Customer: 'I want net retention by weekly cohort, with the churn segments broken out.' AI builds it. Preview shows the chart. Customer: 'Make the cohorts monthly instead.' AI adjusts.
  4. Lock it in. When the customer says 'this is it,' Yael commits with her name as author and the customer as co-author. PR opens.
  5. Agents review what was co-designed. Security, code-review, test, policy. The customer's idea makes it past the gate and into the next release.

Outcome: Customer feedback turned into shipped code in one session.

Support reproduces a customer bug (Support)

An enterprise customer reports invoices showing the wrong total. Tom (support) needs to reproduce fast and hand off a clean repro to engineering.

  1. Env from the customer's exact state. Tom creates an env from the customer's deployed commit. He drops the customer's invoice CSV into Extra Context — the AI now has the exact payload.
  2. Reproduce in the live preview. He opens the Preview, walks the same flow the customer described, sees the same wrong total — off by $0.07 per line item.
  3. Inspect the database. Database panel: query the invoices table. Tom spots a rounding mismatch between the tax rows (stored in cents) and the totals row (stored in dollars-as-float).
  4. Hand the env to engineering. Share link to the eng oncall. Everything they need — branch, customer data, the exact repro — is in the env. No 'works on my machine' loop.
  5. Engineer fixes in the same env. Chat: 'Round all monetary values at one boundary, add a regression test using the attached invoice.csv.' AI fixes, tests pass, PR opens, agents green-light it. Tom closes the ticket.

Outcome: From bug report to merged fix in a single env — no repro back-and-forth.

Day-one onboarding without 'set up your machine' (People ops · Engineering)

It's Sara's first day. Instead of two days of laptop setup, she opens an env.

  1. Pre-baked onboarding env. Sara opens her welcome link. The env is already seeded with the repo, demo data, and a curated chat thread from her manager explaining the codebase.
  2. AI as the docs. Chat: 'Walk me through how routing works.' AI reads the real code and explains. 'Show me the request lifecycle.' AI traces it through the actual files she's about to touch.
  3. Try real things, safely. Terminal panel for pnpm test, Preview to see her changes — Sara experiments without fear of breaking anything. The env is hers; main is untouched.
  4. First PR by day three. She fixes a small typo in the docs and adds her name to AUTHORS.md. AI helps her write the commit message. Git panel pushes. Her name in main.
  5. Graduate to local when she's ready. When Sara wants a local dev loop, she clicks Export. The env's files come down to her machine, configs and all. From there it's a normal repo.

Outcome: New hires productive on day one, no setup week.

Throwaway spike for a risky idea (Engineering)

Lior wants to try migrating a chunk of the UI to React 19's new compiler. He doesn't want to touch his local repo or pollute branches if it doesn't pan out.

  1. Throwaway env, named 'spike-react19'. One click from main. Real code, real tests, but everything is scoped to this env. He can delete the whole thing in one click later.
  2. Heavy refactor in local VSCode. VSCode tunnel. Lior wants his keyboard shortcuts, his Vim plugin, his AI in the editor and the AI in the chat side-by-side.
  3. Iterate with two AI surfaces. Chat: 'Convert all class components in src/ui to function components.' Lior reviews each change in his IDE, tweaks, runs tests in the env's terminal as he goes.
  4. Decide. Tests pass, bundle size drops 18%. Lior pushes the branch — it's now a real PR, with no record of the failed mid-experiments. If it had failed, he'd have deleted the env and his repo would be untouched.

Outcome: Risky experiments without commits on your record or noise in main.