Shared Spaces

Learn how to create and manage shared spaces, collaborate on documents with team members, use discussion areas for asynchronous communication, and enable version control and multi-person collaboration through Git.

3.1 Shared Space Overview

What is a Shared Space

A shared space is a team or project-level data boundary, the core unit for multi-person collaboration in MeshWork. Each shared space contains the following key parts:

• Public Library: Stores team-shared documents, knowledge, resources, and long-term settled content.
• Discussion Area: Place for asynchronous discussion around shared content, supporting topic status, participants, and intelligent dialogue.
• Shared Attachments: Images, files, and other media resources shared by the team.
• Git Configuration: Optional version control and remote collaboration features.

Relationship Between Shared Spaces and Private Library

In MeshWork, the private library and shared spaces are two independent data boundaries:

• Private Library: Belongs to the current user, storing personal long-term notes, research materials, writing drafts, inspiration fragments, and content that shouldn't automatically enter team sharing.
• Shared Space: Belongs to a team or project, storing team-shared knowledge, discussions, and collaboration content.

The workspace is responsible for combining one private library and multiple shared spaces. You can simultaneously participate in multiple different shared spaces, such as your company's product planning space, open source project documentation space, friends' content creation space, etc.

Shared Space Application Scenarios

Shared spaces are suitable for various team collaboration scenarios:

• Product Planning Team: Collect market research, competitive analysis, requirement documents, and product planning.
• Content Creation Team: Collaborative writing of articles, books, video scripts, and marketing content.
• Research Discussion Group: Academic paper discussions, research note sharing, and opinion exchange.
• Open Source Project Maintenance: Project documentation, development guides, and community discussions.
• Education and Training: Course material sharing, learning discussions, and assignment collaboration.

Shared Spaces in the Sidebar

In the workspace main interface, shared spaces are located in the lower half of the sidebar:

• Private Library: Fixed in the upper half of the sidebar, always visible.
• Shared Space List: Located in the lower half of the sidebar, multiple shared spaces can be added.
• Add Button: Below the shared space area is a + button for creating or joining new shared spaces.

Under each shared space, two sub-items can be expanded: Public Library and Discussion Area. Clicking the corresponding sub-item displays the related content in the main content area.

3.2 Creating Shared Spaces

Preparation Before Creating

Before creating a shared space, it's recommended to clarify the following points:

• Team size: Determine the number of members and role division in the participating team.
• Collaboration goals: Clarify the main purpose of the shared space, such as product documentation, content creation, research discussion, etc.
• Git requirements: Consider whether version control and remote collaboration are needed. For small teams, you can use it locally first and configure Git later.
• Directory location: Choose an appropriate disk directory location to store shared space data.

Creation Steps

To create a new shared space:

1. Open creation interface: In the workspace main interface, click the + button below the sidebar.
2. Select creation type: In the pop-up menu, select "Create Shared Space".
3. Enter basic information:
   • Enter the shared space name, such as "Product Planning Team" or "Content Creation Studio".
   • Select the local storage directory. MeshWork will create the shared space's data structure under the specified directory.
   • Choose whether to use a template. If creating for the first time, it's recommended to select "Empty Template", and you can add content later according to actual needs.
4. Configure Git (optional):
   • If version control is needed, you can select "Configure Git".
   • Enter the remote repository address (such as GitHub repository address).
   • Enter the branch name. When left blank, MeshWork will automatically generate a branch name based on the shared space name and ID.
   • If version control is not needed for now, you can select "Configure Later".
5. Complete creation: Click the "Create" button, and MeshWork will create the complete directory structure of the shared space in the specified directory.

Directory Structure

After creation is complete, the shared space directory structure is as follows:

<shared-space>/
├── .meshwork/           # MeshWork metadata and configuration
├── public-knowledge/    # Public library documents
├── discussions/         # Discussion area data
└── assets/             # Shared attachments and media resources

Initial Interface

After creation is complete, you will see the following interface changes:

• The new shared space will appear in the shared space list in the sidebar.
• You can expand the shared space to see two sub-items: "Public Library" and "Discussion Area".
• By default, the Public Library will open, displaying an empty document tree.
• You can start creating documents, organizing folder structures, and inviting team members to join.

3.3 Joining Shared Spaces

Getting Invitation Information

To join an existing shared space, you first need to obtain that shared space's invitation information. Invitation information is usually provided by the shared space's creator or administrator and contains the following key information:

• Remote repository URL: The Git remote repository address bound by the shared space.
• Branch name: The branch name of the shared space in the remote repository.
• Shared space name: Suggested name for local directory naming.

Joining Steps

To join an existing shared space:

1. Open join interface: In the workspace main interface, click the + button below the sidebar.
2. Select join type: In the pop-up menu, select "Join Shared Space".
3. Enter invitation information:
   • If you received a MeshWork invitation text, directly press Command+V to paste it into the interface. The system will automatically parse and fill the following fields:
     • Remote repository URL
     • Branch name
     • Local name (if not yet entered)
   • If there is no invitation text, manually enter the remote repository address and branch name.
   • Enter the local directory name for storing shared space data locally.
   • Select the local storage directory location.
4. Clone remote content:
   • After clicking the "Join" button, MeshWork will clone the specified branch's content from the remote repository.
   • First-time joining may take some time, depending on network speed and remote repository size.
   • After cloning is complete, the local system will have the complete shared space history and current content.
5. Start collaborating:
   • After successful joining, the shared space will appear in the sidebar.
   • You can view documents in the Public Library, participate in Discussion Area topics, and collaborate with team members in real time.

Permissions and Access Control

After joining a shared space, your permissions depend on the remote repository's access settings:

• Write permission: Can edit documents, create discussions, and push changes to the remote repository.
• Read-only permission: Can view content but cannot modify or push changes.
• Admin permission: In addition to write permission, can manage team members, adjust settings, and configure Git.

Troubleshooting Join Issues

When joining a shared space, you may encounter some common problems:

• Authentication failed: Check whether the SSH key or Personal Access Token is correctly configured.
• Repository doesn't exist: Confirm whether the remote repository URL is correct and whether the repository has been deleted.
• Branch doesn't exist: Confirm whether the branch name is correct, case-sensitive.
• Insufficient permissions: Confirm whether you have permission to access the repository.

3.4 Sharing Shared Spaces

Preparation Before Sharing

Before sharing a shared space, you need to ensure the following points:

• Git configured: The shared space must be bound to a remote Git repository to be shared.
• Content pushed: Ensure local changes have been pushed to the remote repository so team members can see the latest content.
• Permissions set: In the remote repository hosting service (such as GitHub), ensure target users have been granted appropriate permissions.

Generating Invitation Text

To generate invitation text for a shared space:

1. Open share interface: Right-click the shared space you want to share in the sidebar and select "Share".
2. View invitation information: The system will open a Sheet displaying the following information:
   • Remote repository URL
   • Branch name
   • Shared space name
   • Auto-generated invitation text
3. Copy invitation text: Click the "Copy Invitation" button to copy the invitation text to the clipboard.

Invitation Text Format

MeshWork's invitation text uses a standardized format containing both human-readable instructions and machine-parsable JSON data:

-----BEGIN MESHWORK SHARED SPACE INVITE-----
{
  "type": "com.meshwork.shared-space-invite",
  "version": 1,
  "name": "Product Planning Team",
  "remoteURL": "[email protected]:example/product-docs.git",
  "branch": "meshwork/shared/product-team"
}
-----END MESHWORK SHARED SPACE INVITE-----

Advantages of this format:

• Human-readable: Even when pasted into chat applications or email, recipients can understand this is a MeshWork invitation.
• Machine-parsable: Recipients can directly paste into MeshWork, and the system will automatically extract necessary information.
• Version-compatible: Includes a version number for future format upgrades and compatibility handling.

Sharing Methods

After generating invitation text, you can share it with team members through various methods:

• System sharing: Use macOS's system share function to send via AirDrop, Messages, Mail, etc.
• Copy and paste: Copy the invitation text and paste it into team communication tools like Slack, WeChat, DingTalk.
• Email sending: Send the invitation text as email content to target users.
• Document sharing: Put the invitation text in a team collaboration document for members to access at any time.

Setting Remote Repository Permissions

Just sending invitation text is not enough; you also need to ensure target users have permission to access the remote repository:

1. Visit the remote repository hosting service (such as GitHub).
2. Enter the repository's "Settings" page.
3. Click "Collaborators" in the left menu.
4. Click the "Add people" button.
5. Enter the team member's GitHub username or email address.
6. Select the permission level (recommend selecting "Write" permission).
7. Click "Add" to send the invitation.

Post-Sharing Management

After sharing a shared space, as creator or administrator, you need to:

• Regularly push updates: Ensure local changes are pushed to the remote repository in a timely manner.
• Resolve conflicts: When multiple members modify the same document simultaneously, assist in resolving merge conflicts.
• Maintain document quality: Ensure document structure in the Public Library is clear and content is accurate.
• Guide new members: Help newly joined members understand the shared space's usage guidelines and best practices.

3.5 Public Library Collaboration

Public Library Overview

The Public Library is the core area for storing team-shared documents in a shared space. Similar to the private library, it supports document editing, folder organization, AI assistance, and other functions, while each document type provides either editing or read-only viewing for team members.

Creating and Editing Documents

To create and edit documents in the Public Library:

1. Open Public Library: Expand the shared space in the sidebar and click "Public Library".
2. Create new document: Click the "New Document" button in the document tree and enter the document title.
3. Organize document structure:
   • Create folders to organize related documents.
   • Use meaningful folder and document names.
   • Follow team naming conventions and directory structure standards.
4. Edit document content:
   • Use the rich text editor to write content.
   • Insert images, links, and code blocks.
   • Use the AI assistant to assist with writing and optimizing content.
5. Save changes: Edits are automatically saved, or you can manually press Command+S to save.

Sharing PDF and Word Materials

The Public Library can also store PDF, .docx, and .doc materials. They participate in Git sync within the shared space boundary and are useful for papers, contracts, product manuals, research reports, and external references that the team reads together.

• Read-only viewing: PDFs use native PDFKit viewing, while Word files use the macOS text system or Quick Look preview. The original files are not edited directly in MeshWork.
• Local OCR: Scanned PDFs can use Apple Vision on-device OCR when embedded text is insufficient, making the content available to search and AI reading.
• Convert for editing: When the team needs to revise or distill the content, use "Convert to Markdown" to create a Markdown file in the same folder and collaborate there.
• Discussion references: Reference these files in Discussion Area messages so AI can read extractable text on demand and include source material in team discussion context.

Sorting the Document Tree

The Public Library document tree also supports sorting. The entry point is in the left sidebar under the relevant shared space: click the + button on the "Public Knowledge" section header, then choose "Sort" from the menu.

• Sort by Name: Best for browsing team documents by file or folder name.
• Sort by Modified: Best for seeing recently updated team documents or finding content that has not been maintained for a while.
• Sort by Created: Best for reviewing project material in creation order.
• Toggle ascending or descending: Click the current sort field again to switch direction. The arrow in the menu shows the current direction.

Each shared space saves its own Public Library sort setting. It does not affect the private library or other shared spaces.

Collaborative Editing Best Practices

When collaborating on document editing with a team, it's recommended to follow these best practices:

• Avoid simultaneous editing of the same document: Try to coordinate with team members to avoid multiple people editing the same document simultaneously, reducing conflicts.
• Small, frequent commits: Push small changes frequently instead of accumulating many changes before pushing once. This makes it easier to track history and resolve conflicts.
• Clear commit messages: When pushing, provide concise, clear change descriptions to help team members understand your modifications.
• Communicate major changes: Before large-scale document restructuring or deletion operations, inform other members in the Discussion Area or team communication tools.
• Regular synchronization: Develop the habit of regularly pulling remote updates to ensure local content stays synchronized with the team.

Document Version History

Through Git's version history functionality, you can:

• View history: View all modification history of a document, including who made what changes when.
• Compare versions: Compare differences between versions to understand specific changes.
• Restore old versions: If important content is accidentally deleted or modified, you can restore from historical versions.
• Trace contributions: Understand each team member's contributions to the document.

Handling Edit Conflicts

When multiple team members modify the same document simultaneously, edit conflicts may occur. Steps to resolve conflicts:

1. Identify conflict: When you try to push changes, if the remote repository has new commits, MeshWork will prompt that a conflict exists.
2. Pull remote changes: First pull the latest remote changes, and MeshWork will attempt to auto-merge.
3. Manually resolve conflicts:
   • If auto-merge fails, conflicts need to be resolved manually.
   • MeshWork will display the conflicting content, letting you choose which version to keep or merge both versions.
   • Carefully check each conflict area to ensure the final content is correct.
4. Push resolved version: After conflicts are resolved, push changes to the remote repository again.

Document Templates and Standards

To maintain consistency and readability in the Public Library, it's recommended to:

• Use document templates: Create templates for common document types, such as meeting notes, requirement documents, technical proposals, etc.
• Establish writing standards: Agree on document formats, structures, naming rules, and language style.
• Build review mechanisms: For important documents, establish review processes to ensure content quality.
• Regular maintenance: Regularly clean up outdated documents, update incorrect information, and optimize directory structure.

3.6 Using Discussion Area

Discussion Area Overview

The Discussion Area is the core tool for asynchronous communication within a shared space. It supports topic discussion, status management, tag classification, and AI intelligent dialogue, helping team members conduct in-depth discussions around shared content.

Creating and Managing Topics

To create and manage topics in the Discussion Area:

1. Open Discussion Area: Expand the shared space in the sidebar and click "Discussion Area".
2. Create new topic:
   • Click the "New Topic" button.
   • Enter a topic title that concisely and clearly describes the discussion theme.
   • Set a clear topic title and initial message so teammates understand the context.
   • Set topic status (such as "Open", "In Progress", "Resolved", etc.).
   • Write the topic's initial content, clearly explaining background, issues, and expected discussion direction.
   • Associate related documents (optional), linking the discussion to specific Public Library documents.
3. Manage topics:
   • Update topic status to reflect current progress.
   • Update the topic title or state when the discussion scope changes.
   • Edit topic titles and content to correct errors or supplement information.
   • Close resolved or no longer relevant topics.

Participating in Discussions

To participate in topic discussions in the Discussion Area:

1. Browse topics: View all discussions in the topic list and use status and timing to decide what needs attention.
2. Reply to topics:
   • Click a topic to enter its detail page.
   • Enter your opinions, suggestions, or questions in the reply box.
   • Supports rich text format, can insert links, code blocks, and images.
   • Can @ mention other team members to draw their attention.
   • Use the AI assistant to help organize viewpoints, generate summaries, or provide intelligent suggestions.
3. Follow topics: For important topics, you can choose to "Follow" so you receive notifications when there are new replies.
4. Quote replies: Can quote specific messages for replies, making discussion structure clearer.

Using AI Assistant

The Discussion Area integrates an AI intelligent assistant providing the following functions:

• Auto-summarize: AI can automatically summarize key points of long discussions, helping team members quickly understand discussion progress.
• Viewpoint extraction: Extract different viewpoints and positions from messy discussions, helping to understand everyone's opinions.
• Issue identification: Automatically identify issues and controversy points in discussions, helping focus on key topics.
• Suggestion generation: Provide possible solutions or next action suggestions based on discussion content.
• Intelligent reply: AI can generate reply drafts based on context, reducing repetitive work.

Topic Knowledge Card: settle discussion into current understanding

As a topic grows, the message flow alone stops being a good answer to questions like "What have we actually agreed on?" or "What is still unresolved?" The Topic Knowledge Card exists for that gap. It does not replace the original discussion. Instead, it keeps the full message history while maintaining one structured card that represents the topic's current state of understanding.

Where to open it

1. Open a topic inside a shared space.
2. By default, the right side of the topic detail view shows the Knowledge Card sidebar. If you hid it earlier, use the discussion toolbar action "Show Knowledge Card" to bring it back.
3. The sidebar header shows the "Knowledge Card" title and provides a button to hide the sidebar again.

What's in the sidebar

• Version history: The upper section shows a timeline of this card's past versions. Each row shows time, author, and version note, and can expand to compare with the current version.
• Current card: The lower section shows the full current body and a coverage hint such as "summarized through message X / Y".
• Edit entry: Click "Edit" to manually revise the current card.
• AI update entry: Click "Update from current discussion" to let AI generate a new draft from the discussion.

How to update the card

1. Click "Update from current discussion": MeshWork opens the update sheet.
2. Choose the message range:
   • Since last review: Only process new messages after the last confirmed coverage point. This is the normal mode for maintaining a long-running topic.
   • Whole discussion: Rebuild the card from the entire topic. Use this when the earlier card is weak or the discussion has changed direction.
3. Review the generated result: The sheet shows a comparison between the current body and the new draft so you can inspect what was added, revised, or removed.
4. Confirm write: The new content is written only after you click "Apply".

Typical interaction scenarios

• Keeping a long topic up to date: After a week of requirement discussion, the owner clicks "Update from current discussion" and chooses "Since last review" so AI only summarizes newly added messages. The card stays current without rebuilding everything each time.
• Helping a new member catch up: A newly joined member can read the current card first to understand the present state, then expand history or return to the original message flow only when deeper traceability is needed.
• Manually correcting a critical decision: The AI draft is mostly right, but one conclusion is phrased too strongly. The owner can generate the draft, then use "Edit" to adjust the wording before saving a new version.

Topic Branches: Possibilities for Infinite Dialogue

MeshWork's Discussion Area supports a unique feature: Topic Branches. This feature allows you to create a new topic starting from any discussion message, achieving infinite extension and subdivision of dialogue.

Why Do We Need Topic Branches?

In team collaboration, discussions often evolve into multiple parallel sub-topics. Traditional chat tools can only linearly stack messages, leading to:

• Scattered focus: One topic mixes multiple related but not identical issues, making it hard to focus
• Information drowning: Important sub-discussions are drowned by many other messages, hard to review
• Repeated communication: To help new members understand background, need to repeatedly explain previously discussed content
• Lack of structure: Discussion becomes a messy message flow, unable to form clear knowledge structure

How to Use Topic Branches?

Creating a topic branch is very simple:

1. Select branch point: In a topic, find the message you want as the starting point for the new topic. This message must be a completed user message (not a system message).
2. Click branch button: Hover over the target message and click the "Branch" icon (arrow branch icon) in the toolbar.
3. AI generates summary: The system will call an AI agent to analyze discussion content from this message to the topic's end, generating a structured summary.
4. Confirm branch information: In the pop-up branch confirmation interface, you can:
   • View the AI-generated discussion summary
   • Edit the new topic title (can be based on AI suggestion or customized)
   • Modify summary content (if needed)
5. Create branch: After confirming, click "Create Branch". The system will generate a new topic containing:
   • System message showing branch source (original topic title and link)
   • AI-generated discussion summary as the first message
   • Association information with the original topic for future traceability

Topic Branch Best Practices

• Branch promptly: When you find discussion starting to deviate from the original theme, promptly create a branch to keep the original topic focused
• Meaningful titles: Give branch topics clear titles that accurately reflect the branch discussion theme
• Utilize summaries: AI-generated summaries contain key context, ensuring new participants can quickly understand background
• Maintain associations: Branch topics retain association with the original topic, can quickly trace back to original discussion when necessary
• Moderate branching: Although unlimited branching is supported, it's recommended to only create branches when truly needed to avoid topic fragmentation

Technical Implementation of Topic Branches

The technical implementation of the topic branch feature reflects MeshWork's careful design of data structures:

• Message-level association: Each message can become a branch starting point, achieving fine-grained dialogue organization
• Metadata tracking: Branch messages contain complete metadata, recording branch source, creator, creation time, etc.
• Context window: When generating summaries, AI considers context window limitations, ensuring summary completeness and accuracy
• Git integration: Topic branch data syncs to all team members according to Git rules

Message-Level Document References

The Discussion Area is closely integrated with the Public Library. When you need AI to focus on a specific document, reference that file in the message instead of maintaining long-term topic-level path associations.

• Explicit references: Reference concrete files in the message to show which materials matter for the current turn.
• On-demand reading: If the answer depends on file content, AI must read or search the referenced document with tools before answering.
• Discussion settling: When discussions form consensus or conclusions, you can organize discussion content into documents and settle them in the Public Library.

Discussion Area Status Management

Discussion Area topics have two simple states to help you manage the discussion lifecycle:

• Open: Active discussion state. All open topics display in the topic list, and team members can continue participating in discussion. This is the default state for newly created topics.
• Archived: Closed or no longer active topics. After archiving, topics don't display in the default topic list but can still view history. Archiving is used to clean up the topic list while preserving discussion history.

Discussion Area Content and Git

Whether content in the Discussion Area enters Git follows these principles:

• Content entering Git:
  • Topic titles and status
  • Participants and tags
  • Message body text
  • The topic knowledge card at discussions/<topic-id>/knowledge-card.md and its version history
  • Sharable render structures directly related to messages
• Content not entering Git:
  • Current user's own session state
  • Current user's own unread status
  • Current user's own drafts
  • Current user's own collapse state
  • Current user's own AI auto-reply window state

This design ensures content that team members should see together and synchronize enters the shared Git, while personal preferences and local state don't affect other members.

3.7 Git Configuration for Shared Spaces

Git Configuration Overview

Git configuration for shared spaces is similar to the private library but has some special considerations:

• Multi-person collaboration: Need to consider situations where multiple members push changes simultaneously.
• Permission management: Ensure team members have appropriate repository access permissions.
• Branch strategy: Multiple shared spaces may use different branches of the same repository.
• Conflict resolution: Need to establish clear conflict resolution processes.

Initializing Git Repository

To initialize a Git repository for a shared space:

1. Open shared space settings: Right-click the shared space in the sidebar and select "Settings".
2. Enter Git configuration: Find the "Git" section in the settings page.
3. Initialize local repository:
   • If the shared space was created in MeshWork, a Git repository may have been automatically initialized.
   • If imported from an external directory, manual initialization may be needed.
4. Configure remote repository:
   • Enter the remote repository URL (such as GitHub repository address).
   • Select connection method (SSH or HTTPS).
   • Enter branch name. When left blank, MeshWork will automatically generate a branch name based on the shared space name and ID.
5. First push:
   • Click the "Push" button to push local content to the remote repository.
   • If the remote repository is empty, this will create the initial commit and specified branch.
   • If the remote repository already has content, it will attempt to merge with local content.

Branch Strategy

MeshWork uses branches to isolate data from different shared spaces:

• Automatic branch naming: If no branch name is specified, MeshWork will automatically generate a branch name based on the shared space name and ID, such as meshwork/shared/product-team.
• Branch isolation: Even if multiple shared spaces use the same remote repository, they will bind to different branches without interfering with each other.
• Custom branches: Teams can customize branch names according to their own branch strategies.

Synchronization and Pushing

In a multi-person collaboration environment, correctly use Git synchronization and push functions:

1. Regular pulling:
   • Develop the habit of regularly pulling remote updates.
   • Pull the latest changes before starting important work.
   • This reduces conflict occurrences.
2. Frequent pushing:
   • Push immediately after completing small tasks instead of accumulating many changes.
   • Small step pushing reduces conflict complexity.
   • Frequent pushing also helps team members understand each other's progress.
3. Pre-push checks:
   • Pull remote updates before pushing.
   • Check if there are conflicts that need resolution.
   • Ensure local content can push to remote normally.

Viewing History and Versions

Utilize Git's history functions to understand the shared space's evolution:

• View commit history: View all members' commit records to understand the shared space's development history.
• Compare version differences: Compare differences between different time points to understand specific changes.
• Trace responsibility: View the author and time of specific changes for communication and collaboration.
• Restore historical versions: If important content is accidentally deleted, restore from historical versions.

Git Configuration Best Practices

When configuring Git for shared spaces, it's recommended to follow these best practices:

• Clear sync rhythm: Sync before and after important edits to avoid long-running divergence.
• Clear commit messages: Encourage team members to provide concise, clear commit messages describing the purpose and content of changes.
• Reasonable branch strategy: Choose appropriate branch strategies based on team size and project characteristics.
• Regular backups: Besides remote repositories, regularly backup important shared space data.
• Permission control: Reasonably distribute team members' repository access permissions based on roles and responsibilities.
• Conflict resolution process: Establish clear conflict resolution processes, including negotiation mechanisms and arbitration methods.

3.8 Small Team Collaboration Example

Scenario 1: Product Planning Team

Team Background

A product planning team of 5 people, including product manager, designer, development engineer, and marketing specialist. The team needs to jointly manage product requirement documents, competitive analysis, user research, and product roadmaps.

Shared Space Setup

1. Create shared space:
   • Product manager creates a shared space named "Product Planning Team".
   • Create a private repository product-planning-2024 on GitHub.
   • Configure Git, using the auto-generated branch name.
2. Organize Public Library:
   • Create folder structure:
     • Requirements/: Store feature requirements, user stories, and acceptance criteria.
     • Competitive Analysis/: Store competitive research reports and market analysis.
     • User Research/: Store user interview records and research data.
     • Product Roadmap/: Store long-term planning and milestones.
     • Design Resources/: Store design specs, prototypes, and visual guidelines.
   • Create templates for each document type to ensure format consistency.
3. Invite team members:
   • Generate invitation text and send to members via team communication tools.
   • Add collaborators on GitHub, granting "Write" permission.
   • Provide new members with shared space usage guidelines.

Collaboration Process

1. Requirement discussions:
   • Product manager creates "New Feature Requirement Discussion" topic in Discussion Area.
   • Team members raise opinions, suggestions, and concerns in the discussion.
   • Use AI assistant to summarize discussion points and extract core requirements.
2. Document writing:
   • Product manager writes requirement documents based on discussion results.
   • Designer adds design spec links, development engineer evaluates technical feasibility.
   • Raise modification suggestions in the discussion area, then update the public document after the team confirms them.
3. Review and confirmation:
   • Create "Requirement Review" topic in Discussion Area.
   • Team members confirm consistent understanding of requirements, clarify next steps.
   • Mark approved requirements as "Confirmed" status.
4. Progress tracking:
   • Update feature status in product roadmap.
   • Regularly sync product progress and changes in Discussion Area.
   • Use Git history to trace requirement change timeline and responsibility.

Best Practices

• Regular synchronization: Publish product progress summaries in Discussion Area weekly.
• Version points: Sync around important milestones and keep clear version history.
• Decision records: Form records of major decisions in Discussion Area for future traceability.
• Cross-team collaboration: Share necessary requirement documents with development team but maintain independence of product discussions.

Scenario 2: Content Creation Studio

Team Background

A content creation studio composed of 3 freelance writers creating articles, blog content, marketing copy, and video scripts for different clients. Team members are distributed in different cities and need efficient remote collaboration tools.

Shared Space Setup

1. Create shared space:
   • Team members take turns creating shared spaces, named according to client projects.
   • Create private repositories on GitHub, repository names include client name and project type.
   • Configure Git for team member content synchronization.
2. Organize Public Library:
   • Create folder structure:
     • Client Materials/: Store client background, brand guidelines, and past cases.
     • Project Planning/: Store content calendars, publishing schedules, and project progress.
     • Article Drafts/: Store articles currently being written.
     • Published Content/: Store final published versions.
     • Media Resources/: Store images, videos, and reference materials.
   • Create writing templates and checklists for different content types.
3. Shared resource library:
   • Create a general "Writing Resources" shared space.
   • Store writing guides, reference materials, tool recommendations, and best practices.
   • All team members can contribute to and maintain this resource library.

Collaboration Process

1. Project kickoff:
   • Create "New Project Kickoff" topic in Discussion Area.
   • Share client requirements and project goals.
   • Assign tasks and set deadlines.
2. Content creation:
   • Each member is responsible for different content parts.
   • Create article drafts in Public Library.
   • Use AI assistant for grammar checking, style optimization, and SEO suggestions.
3. Mutual review:
   • After completion, create "Review Request" topic in Discussion Area.
   • Other members provide modification suggestions and feedback.
   • List issues and improvement points in the discussion area, then have the owner update the document.
4. Client delivery:
   • After final confirmation, move content to "Published Content" folder.
   • Record publishing channels and publication dates.
   • Summarize project experience and client feedback in Discussion Area.

Best Practices

• Unified style: Maintain style guides to ensure consistent content style from different authors.
• Version control: Use Git history to track content modifications, facilitating rollback and version comparison.
• Resource sharing: Build reusable material libraries to avoid duplicate data collection.
• Quality assurance: Establish checklists to ensure all content meets quality standards before delivery.

Scenario 3: Research Discussion Group

Team Background

An academic discussion group composed of graduate students and researchers, researching AI ethics. Members are distributed in different universities and need to regularly share research progress, discuss paper viewpoints, and collaboratively write academic papers.

Shared Space Setup

1. Create shared space:
   • Group leader creates "AI Ethics Research" shared space.
   • Create private repository on GitHub for long-term maintenance.
   • Configure Git to save research materials and discussion history.
2. Organize Public Library:
   • Create folder structure:
     • Literature Review/: Store reading notes and summaries of important papers in the field.
     • Research Ideas/: Store initial thoughts and exploration of research questions.
     • Experimental Design/: Store experimental protocols and data collection plans.
     • Paper Drafts/: Store collaboratively written academic paper drafts.
     • Meeting Notes/: Store records of online meetings and action items.
     • Resource Links/: Store valuable websites, databases, and tool links.
   • Create unified templates for paper reading, including research questions, methods, results, and critical thinking.
3. Setup Discussion Area:
   • Create tag categories:
     • "Paper Discussion": In-depth discussion on specific papers.
     • "Research Ideas": Preliminary exploration and feedback on new ideas.
     • "Method Exchange": Discussion on research methods and experimental design.
     • "Writing Collaboration": Specific issues and division of labor in paper writing.
   • Establish topic status norms:
     • "Discussing": Topics actively under discussion.
     • "Needs Feedback": Topics waiting for member feedback.
     • "Consensus Reached": Discussions completed and forming conclusions.

Collaboration Process

1. Regular paper sharing:
   • Weekly rotation in Discussion Area sharing an important paper.
   • Sharer creates reading notes in Public Library.
   • Other members raise questions and viewpoints in Discussion Area.
   • Use AI assistant to summarize similarities and differences in different viewpoints, promoting deep thinking.
2. Research idea incubation:
   • Members can propose new research ideas in Discussion Area at any time.
   • Other members provide feedback, related literature, and improvement suggestions.
   • Mature ideas transfer to "Research Ideas" folder for further development.
3. Collaborative paper writing:
   • Determine paper theme and outline.
   • Create writing plan topic in Discussion Area, clarifying division of labor and progress.
   • Each member responsible for different sections, collaboratively editing in Public Library.
   • Regularly sync progress in Discussion Area, resolving writing issues.
   • Use Git history to track each person's contributions.
4. Meeting record organization:
   • After online meetings, create meeting record topic in Discussion Area.
   • Record discussion points, decisions, and action items.
   • Use AI assistant to extract to-do items from meeting records.
   • Organize mature meeting records into documents, store in Public Library.

Best Practices

• Deep discussion: Leverage asynchronous discussion advantages, encourage members to spend time thinking deeply before replying, pursuing quality over speed.
• Knowledge settling: Regularly organize insights from discussions into documents, forming the group's knowledge base.
• Academic norms: When citing literature in discussions, follow academic citation standards for easy future retrieval and citation.
• Open and inclusive: Encourage expression of different viewpoints, creating a safe discussion environment.
• Cross-timezone collaboration: Consider members may be distributed across different time zones, avoid requiring real-time online presence.

Research Achievement Management

• Version tracking: Sync at important stages and record version notes such as first draft, revised draft, and submission version.
• Feedback integration: Discuss peer review opinions one by one in Discussion Area, then integrate into the paper.
• Publication records: Maintain paper publication list in Public Library, including journals, conferences, and citations.
• Data sharing: For publicly shareable data and code, maintain in shared space to facilitate research reproduction.