Vibe coding with friends, in one live workspace

Vibe coding started as a solo activity: one person, one AI, describing an app and reacting to what comes back. It is fun, and it is even better with other people. Someone has the product idea, someone spots the bug, someone asks the question nobody else thought of.

The problem is that most AI coding tools assume one person per project. Friends end up screen-sharing, pasting snippets into chat, or each running their own agent on their own copy and merging the mess later. Vibe coding with friends works when everyone, and every agent, is in the same workspace and can see each other.

Code Crux is a collaborative, AI-native code editor that runs in the browser. Four pieces make group sessions work.

Live cursors and presence

Everyone edits the same files in real time and sees each other’s cursors as they move. Crux syncs changes with CRDTs (built on Yjs), so simultaneous edits merge instead of overwriting each other.

AI agents you can see

Agents show up on files the same way people do. When a friend’s agent is rewriting the API route, you can see it there, and you send your own agent somewhere else. That one detail removes most of the chaos of several people prompting at once.

A built-in agent panel and model picker

The agent panel docks to the side or floats over your code, and quick ask handles one-off questions without leaving the file. The model picker lets each person choose a model, including local models through Ollama. Our guide to using Ollama in your code editor covers the local setup.

A canvas and a terminal

The spatial code canvas lays out files as cards wired by the connections in your code, so the group can point at the same part of the map. The integrated terminal sits next to the code for running the app and tests, and a file explorer is there when you want the classic tree.

Six steps from an empty workspace to a group of people and agents building the same thing.

1. 01

   Open a workspace

   Join the Code Crux waitlist to get access. Once you are in, open the browser IDE and import a project folder, or start a fresh project for the session.

2. 02

   Invite your friends with the right access

   Select Share and choose an access level for each person: Can edit for full collaborators, Limited to let someone edit only the files and lines you pick, or Can view for people who want to watch live, read-only.

3. 03

   Agree on the goal and split the work

   Spend two minutes on what you are building and who owns which part, such as one person on the UI, one on the API and one on tests. Write it in a README so the AI agents can read it too.

4. 04

   Put the map on screen

   Switch to the Canvas view to see files as cards wired by the connections in your code. Arrange the cards for the feature you are building so everyone shares the same picture.

5. 05

   Bring in the AI agents

   Open the agent panel, docked to the side or floating, and pick a model in the model picker, including a local Ollama model if you prefer. Agents show up on the files they are working in, just like teammates.

6. 06

   Run it and review together

   Run the app and tests in the integrated terminal, then read through what the agents changed before moving to the next task. Small loops keep the session fun and the code understandable.

Crux is pre-launch, so step one starts with the waitlist. The Crux docs cover the IDE controls, and our pair programming guide goes deeper on sharing links and access.

• Weekend hackathon. Three friends, one idea, one afternoon. Split by area (UI, data, tests) and give each person their own agent.
• Build night with a mentor. Beginners prompt; someone experienced watches with view-only access and explains what the AI wrote.
• Game jam. One person tunes the game feel, another has an agent generate levels, a third fixes bugs as they show up.
• Study group. Everyone tries the same prompt with a different model, then compares results on the canvas.
• Side-project standup. Fifteen minutes on the canvas to agree on next steps, then everyone works in parallel.

• One goal per session. “Add login” beats “make it better.” Agents do their best work on small, clear tasks.
• Give each agent a lane. Agree which files or folders each person’s agent may touch, and watch presence to keep to it.
• Write the plan where the AI can read it. A short README or TODO file keeps every agent working from the same brief.
• Review in rounds. After each burst of generation, stop and read the changes together. It is faster than untangling later.
• Run it often. Keep the app or tests running in the terminal so problems show up while everyone still remembers what changed.
• Keep secrets out. Never paste API keys into prompts or shared files; use environment variables.

Code Crux is pre-launch and still changing. It is a workspace for building together, not a one-prompt app generator or a hosting platform. If you want a deployed app from a single prompt, a builder like Lovable, Bolt, v0 or Replit may suit that job better. Our comparison of vibe coding tools covers the trade-offs honestly, and Crux vs Cursor compares Crux with a single-player AI editor. For plans, see pricing, and for more head-to-heads, the compare page.

What does vibe coding with friends mean?

It means building software together with AI doing much of the typing: several people describe what they want, AI agents write the code, and everyone shapes the result in the same live workspace instead of passing files around.

Can multiple people use AI agents in the same project at once?

In Code Crux, yes. Collaborators edit the same project in real time, and AI agents appear on the files they are changing, so everyone can see where each agent is working and avoid stepping on each other.

Do my friends need to install anything?

Code Crux runs in the browser, so collaborators open the workspace from a link. Crux is pre-launch, so each person needs access through the waitlist.

Is it free to vibe code with friends in Crux?

Crux is pre-launch. Check the Code Crux pricing page for the plans as published, and join the waitlist for access. Cloud AI models may also have their own costs; local Ollama models run on your own hardware.

How do we stop AI agents from overwriting each other?

Give each person and their agent a clear area of the code, keep tasks small, and watch presence on the canvas so two agents are not sent into the same file. Review changes together after each round.