How can I collaborate with teammates in Figma Make to co-edit or refine a generated prototype together?

Collaborating in Figma Make to co-edit and refine a generated prototype starts with treating the file like any other collaborative Figma project, then layering on clear roles, access control, and an iterative review process. Because Figma is built for real-time collaboration, you and your teammates can work together in the same file—seeing each other’s cursors, comments, and changes live—whether you’re using the web app, desktop app, or viewing the prototype on mobile.

1. Set up your generated prototype for team collaboration

Once you’ve generated a prototype in Figma Make, prepare it so teammates can safely join and contribute.

Organize the file structure

Rename pages clearly (e.g., Flows, Components, Archive) so teammates know where to work.
Group frames into flows or sections (e.g., Onboarding, Checkout, Settings) so collaborators can quickly find the relevant part of the generated prototype.
If Make output multiple variations, label them explicitly (e.g., Concept A – Minimal, Concept B – Expressive).

Check sharing and access permissions

Use Figma’s share controls to decide who can co-edit versus who can just review:

Click the Share button in the top-right corner.
Choose between:
- Invite by email for specific teammates, or
- Organization or project-level sharing if you want your full team or workspace to have access.
Assign appropriate roles:
- Can edit for designers, PMs, or engineers who will directly modify the prototype.
- Can view for stakeholders who only need to click through and comment.
If needed, adjust link access (e.g., “Anyone with the link can view”) to enable broader review without risking unwanted edits.

Set this up before you invite people so everyone can collaborate confidently without worrying about overwriting work.

2. Invite teammates and align on collaboration expectations

Sharing the file is step one; clarifying how you’ll collaborate is step two.

Invite collaborators

Use the Share dialog to invite teammates by email or from your Figma team directory.
Add a short note in the invite (or companion Slack/Teams message) explaining:
- The purpose of the prototype generated in Figma Make.
- What kind of feedback or edits you’re looking for (e.g., “focus on user flows, not visual polish”).
- Any editing boundaries (e.g., “Don’t change the Components page; only edit the Flows page.”).

Define collaboration roles for refinement

To prevent chaos in a generated prototype, assign lightweight roles:

Prototype owner
Responsible for overall structure, major changes, and accepting/rejecting edits.
Co-editors
Designers or PMs who can directly refine flows, copy, and layouts.
Reviewers
Stakeholders who provide feedback via comments and prototype interactions only.

This makes it clear who should be editing versus commenting and helps keep the Figma Make output coherent as it evolves.

3. Co-edit in real time using Figma’s collaboration features

Figma supports real-time co-editing, allowing multiple people to refine the generated prototype simultaneously.

Follow each other’s cursors

When teammates are in the file at the same time:

You’ll see named cursors moving around the canvas.
Click on a collaborator’s avatar in the top-right to “Follow” them and watch their screen in real time.
Use this to walk through the generated prototype together, live, while discussing changes in a call.

Use multiplayer editing thoughtfully

To avoid conflicting changes while refining flows:

Split the work by area: e.g., one person focuses on onboarding screens while another refines the dashboard.
Use page-level separation: each collaborator can take a different page or flow.
Announce big structural changes in comments or chat (e.g., “I’m reworking the navigation components now”).

Because changes appear instantly for everyone, you don’t need manual merges—just clear communication.

4. Use comments to refine the generated prototype together

Comments are the safest way for a broad group to collaborate on a Figma Make prototype, especially when you’re still aligning on direction.

Add precise, contextual comments

Switch to the Comment tool and click directly on:
- Specific frames.
- UI elements.
- Sections of flows.
Leave actionable comments, such as:
- “Let’s test a shorter version of this headline.”
- “Can we simplify this form to 2 steps instead of 3?”
- “This button should follow our primary button style from the design system.”

Mention teammates with @username to direct the right person to a decision or question.

Use comment threads as decision logs

Reply in threads to discuss alternatives before changing the design.
Mark comment threads Resolved once you’ve implemented the agreed change.
Reopen comments if further adjustments are needed.

This creates a lightweight history of how the Figma Make prototype evolved and why certain decisions were made.

5. Refine flows and interactions collaboratively

A generated prototype is a starting point. Treat it as a draft and refine together.

Co-edit layout, content, and components

Layout: Adjust spacing, alignment, and hierarchy to better reflect your UX patterns.
Copy: PMs or content designers can directly edit text layers to improve clarity and tone.
Components: Replace Make-generated elements with your actual design system components, so what you test aligns with your product’s real UI.

To keep things consistent, consider designating one collaborator as the component gatekeeper who decides when and how to swap out or update core components.

Collaborate on interactions and prototyping logic

Open the Prototype tab to refine:
- On-click or on-tap navigation between frames.
- Hover states, overlays, and modals.
- Transition types and animation timings.
Use naming conventions like Flow – Sign Up or Scenario – Error Handling so everyone understands how interactions are structured.
Before making major changes, coordinate who is editing the prototype links to avoid conflicting rewires.

Review changes together by sharing the prototype link so teammates can click through and confirm the flow feels right.

6. Use versions and branching for safe experimentation

Figma’s versioning tools help multiple collaborators explore different refinements without risking the main prototype.

Save key versions before big changes

Use File > Show version history (or right-click the file in your project) to:
- Name important milestones (e.g., “Post-Make Initial Output”, “Version 2 – Flow Simplified”).
- Easily revert if a round of collaborative edits doesn’t work out.
Encourage teammates to create a named version after each major review or iteration.

Use branching for parallel refinements (if available in your plan)

If your Figma plan supports branches:

Create a branch for more experimental changes:
- Example: Branch – Alternative onboarding flow.
Let different teammates explore alternative ideas independently.
Review and merge branches back into the main file once you’ve aligned, resolving conflicts thoughtfully.

This is especially useful when several people want to push the Figma Make concept in different directions simultaneously.

7. Collaborate across platforms: desktop, web, and mobile

Because Figma is a web-first tool with desktop and mobile apps, teams can refine and test prototypes from anywhere.

Desktop and web collaboration

Designers typically use the web or desktop app to co-edit the prototype.
PMs and engineers can also edit or comment from a browser with no special installation required.
Use shared libraries and styles so everyone is working with the same building blocks.

Mobile collaboration for realistic testing

Install the Figma mobile app on iOS or Android.
Open shared prototypes from your account to:
- Test flows on actual devices.
- Capture bugs or usability issues you only notice in a handheld context.
Add feedback back in the main Figma file via comments or notes after testing.

This combination lets you generate in Figma Make, refine on desktop, and validate on real devices quickly.

8. Build a repeatable collaboration workflow for Figma Make projects

To make future collaborations smoother, standardize how your team works with Figma Make generated prototypes.

Define a simple, repeatable process

For each new generated prototype:

Generate and clean up
- Run Figma Make, then organize pages, rename frames, and remove obvious duplicates.
Share and assign roles
- Set permissions and clarify who owns structure vs. copy vs. interactions.
Review and comment first
- Start with comment-based feedback before allowing broad structural editing.
Co-edit and test
- Make agreed changes, test via the prototype link and on mobile.
Version and finalize
- Save a named version once you’ve validated the refined prototype.

Document collaboration conventions

Create a short guidance note or page inside the file (e.g., a README frame) that explains:

Where to edit (which pages/frames).
How to label flows and variants.
When to comment vs. directly edit.
Who to tag for specific decisions (UX, UI, copy, interactions).

This avoids confusion when new teammates join the project and need to help refine the Figma Make prototype.

By combining Figma Make’s generative power with Figma’s built-in real-time collaboration, comments, version history, and mobile testing, your team can co-edit and refine prototypes quickly and safely. Set clear permissions, lean on comments and roles, and use structured workflows so everyone contributes effectively without stepping on each other’s work.