# Vibe Coding Team Collaboration Tips

> Collaborating with others using Vibe Coding on projects



Hello, I'm Yupi.

In practical work, many projects are completed through team collaboration.

You might wonder: Is team collaboration still necessary when using AI for development? Can't everyone just use AI individually?

Actually, no. Team collaboration involves many issues that need to be addressed, such as inconsistencies in code generated by AI (A uses React, B uses Vue), A modifying code without B knowing, conflicts arising from multiple people editing the same file, and so on...

In Vibe Coding team collaboration, in addition to traditional team collaboration methods, you can leverage the features of AI development tools to improve efficiency. In this article, I'll share some best practices for teams using Vibe Coding.




## 1. Code Standards and Style

The first step in team collaboration is unifying code standards.



### Why Unify Standards?

If everyone's AI-generated code has different styles, the project will become chaotic. For example, A uses React Class components, B uses functional components; A uses CSS Modules, B uses Tailwind; A's variable names are camelCase, B's are snake_case...

Such code is difficult to maintain and collaborate on. Therefore, the team needs unified code standards.




### Creating a Code Standards Document

You can create a `CODE_STYLE.md` document to clearly define the following.

1) Tech Stack Standards:

- Frontend Framework: React 19 + TypeScript
- State Management: Zustand
- Styling Solution: Tailwind CSS
- Routing Solution: React Router v6

2) Code Style Standards:

- Components: Functional Components + Hooks
- Naming: PascalCase for components, camelCase for functions, UPPER_SNAKE_CASE for constants
- File Organization: One component per file, file name matches component name
- Import Order: React → Third-party Libraries → Internal Modules

3) Comment Standards:

- Complex logic must be commented
- Comments should explain "why" not just "what"
- Use JSDoc format for function documentation

It's recommended to place this document in the project root directory so everyone can see it.




### Using Linter and Formatter

Having a document is not enough; many people don't read it even if it exists. Tools are needed to enforce compliance.

![](https://pic.yupi.icu/1/image-20260105172241747.png)

ESLint is a code inspection tool that automatically detects issues and non-compliant code.

Prettier is a code formatting tool that automatically unifies code format, such as indentation, line breaks, quotes, etc.

Together, they are a powerful duo for cleaning up bad code!

If you don't understand these tools, no problem, you can directly ask AI to install and configure them:

```markdown
Please configure ESLint and Prettier to ensure consistent team code style.
```

AI will help you create a `.eslintrc.json` code inspection configuration file in the project root directory:

```json
{
  "extends": [
    "eslint:recommended",
    "plugin:react/recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "rules": {
    "react/react-in-jsx-scope": "off",
    "@typescript-eslint/no-explicit-any": "error",
    "no-console": "warn"
  }
}
```

Create a `.prettierrc` code formatting configuration file:

```json
{
  "semi": true,
  "singleQuote": true,
  "tabWidth": 2,
  "trailingComma": "es5",
  "printWidth": 100
}
```

And add scripts to `package.json`:

```json
{
  "scripts": {
    "lint": "eslint . --ext .ts,.tsx",
    "lint:fix": "eslint . --ext .ts,.tsx --fix",
    "format": "prettier --write \"src/**/*.{ts,tsx}\""
  }
}
```

This way, before committing code, running `npm run lint:fix && npm run format` will automatically ensure the code complies with standards.




### Unifying AI Configuration

If the team uses Cursor, you can add a `.cursorrules` file to the project to unify AI behavior:

```
Project: 【Project Name】

Tech Stack:
- React 18 + TypeScript
- Tailwind CSS
- Zustand

Code Standards:
- Use functional components
- All components must have TypeScript type definitions
- Use only Tailwind CSS for styling
- Do not use any type

All team members must follow these standards.
```

This way, the code style generated by AI will be more consistent across different team members.

If the team uses Claude or other AI tools, you can also unify standards in a similar way. For example, at the start of each conversation, have the AI read the project's standards document, or include the team's code standards in the system prompt. Specific practices may vary by tool, so it's recommended to check the official documentation of the AI tool.




## 2. Team Collaboration Features of AI Programming Tools

Modern AI programming tools offer dedicated team collaboration features that can significantly boost team efficiency.




### Cursor Team Edition

Cursor offers a dedicated [Team Edition](https://cursor.com/cn/docs/account/teams) with the following features:

1) Team Management and Permission Control

You can create teams, invite members, and set different roles and permissions. Administrators can control who has access to which features, view team usage, and billing.

2) Shared Configuration Files

By sharing rule files, teams can unify AI behavior standards. All members' AI will follow the same code standards, tech stack requirements, and output formats, ensuring consistent code style.

3) Usage Analysis and Monitoring

Team admins can view the team's AI usage, including which members use it the most, which models are used, and the cost incurred. This helps optimize the team's AI usage strategy.

![](https://pic.yupi.icu/1/cursor-dashboard.jpeg)



### Claude Shared Capabilities

Claude offers a [Projects feature](https://www.anthropic.com/news/projects) that is particularly suited for team collaboration:

1) Project-Level Knowledge Base

You can create an independent knowledge base for each project, uploading project-related documents, code, standards, etc. When team members use Claude within this project, the AI will automatically reference this knowledge, maintaining context consistency.

![](https://pic.yupi.icu/1/claudeprojectknowledge.png)

2) Custom Instructions

You can set custom instructions for each project, such as "Use formal tone" or "Answer from a data analyst's perspective." When team members use it, the AI will automatically follow these instructions.

3) Conversation Sharing

Claude Team users can share excellent conversations to the team's activity stream. Other members can see how others use AI, learning different questioning techniques and solutions, thereby improving the team's overall AI usage level.

![](https://pic.yupi.icu/1/claudeshare.jpeg)

4) Team-Shared `CLAUDE.md` File

Even without using the Projects feature, you can manage the `CLAUDE.md` file with Git to enable team sharing and maintenance.

Whenever you find Claude making a mistake, add it to `CLAUDE.md`, so Claude knows not to do it next time. This file will gradually accumulate the team's development experience and standards, becoming a shared knowledge base.




## 3. Documentation-Driven Development

Good documentation is the foundation of team collaboration.




### Importance of Project Documentation

In a team, documentation is more important than in individual development. Because the code you write is not just for yourself, but also for others. Good documentation helps team members quickly understand the project, reducing communication overhead.

Essential documents include:

- README.md: Project overview and usage instructions
- CONTRIBUTING.md: How to contribute to development
- CODE_STYLE.md: Code standards
- API.md: API documentation
- CHANGELOG.md: Version update history



### Contents of README.md

README.md is the face of the project, like the cover and table of contents of a book. It's the first file new members see when joining the project and the window for other developers to understand your project. A good README helps people quickly grasp the project and get started with development.

A good README.md should include:

- Project Introduction: What the project does, what problems it solves
- Quick Start: How to install dependencies, configure the environment, run the project
- Tech Stack: Technologies used and why they were chosen
- Directory Structure: Purpose of main folders
- Development Standards: Code style, commit standards, etc.
- FAQs: Common issues newcomers face and solutions




### API Documentation

If the project has backend APIs, clearly document each interface's usage. You can use tools like Swagger, Postman, or AI to generate API documentation, or write Markdown documents manually.

Each interface should explain:

- Request method and path
- Request parameters (type, required, description)
- Response format
- Error codes
- Usage examples




### Let AI Write Documentation

Writing documentation is tedious, but AI can help.

If you use Cursor, Claude Code, or other AI programming tools, the tool will automatically read the project structure as context. You don't even need to paste the code yourself, just say:

```markdown
Please generate API documentation for this project
```

The AI will generate it automatically based on the code.

If using other AI tools, you can manually paste the code:

```markdown
Please generate documentation for this API interface:
【Paste your code】

The documentation should include: interface description, request parameters, response format, usage example
```

The AI will generate a basic document, which you can then adjust based on actual needs.




## 4. Git Collaboration Workflow

Git is a version control system and the core tool for team collaboration. It's like taking snapshots of your code, allowing you to revert to any previous version at any time. It records who changed what code and when, enabling team members to develop different features simultaneously and merge them later.

💡 If you want to systematically learn and master Git, you can read [Yupi's Git & GitHub Learning Path](https://www.codefather.cn/course/1789189862986850306/section/1789190804671012866).



### Branch Management Strategy

Branches are like parallel worlds of code. You can freely modify code in your branch without affecting others. Once done, merge it into the main branch, like moving your work into the official version.

Team development should leverage branch functionality effectively. Common branch strategies include:

- main branch: Stable production code, only accepting tested code
- develop branch: Development branch, where daily development happens
- feature branch: Each new feature gets its own branch, like `feature/user-login`, `feature/post-editor`
- bugfix branch: Branches for fixing bugs, like `bugfix/login-error`

The workflow is:

1. Create a feature branch from develop
2. Develop on the feature branch, submit a Pull Request once done
3. After review, merge into develop
4. Regularly merge develop into main

![](https://pic.yupi.icu/1/gitcooperate%E5%A4%A7.jpeg)




### Commit Standards

Unified commit messages make it easier for the team to track changes. It's recommended to use the [Conventional Commits standard](https://www.conventionalcommits.org/zh-hans/v1.0.0/), a standardized commit message format that makes the purpose of each commit clear.

For example:

```
feat: Add user login functionality
fix: Fix navbar display issue on mobile
docs: Update API documentation
style: Format code
refactor: Refactor user service
test: Add login functionality tests
chore: Update dependencies
```

Type + colon + space + brief description, making it clear what the commit does.

Many AI programming tools now support generating commit messages, making it easier to follow standards.

![](https://pic.yupi.icu/1/image-20260105172920015.png)



### Pull Request Workflow

Pull Request (PR) is a code merge request. When you finish development on your branch, don't merge directly into the main branch. Instead, create a PR for others to review your code. Only after approval can it be merged. It's like submitting homework for the teacher to grade; it's only complete after passing.

The specific workflow is:

- Create PR: Create a PR on GitHub, clearly stating what changes were made and why.
- Code Review: At least one other member reviews the code, checking functionality, code quality, and compliance with standards.
- Discussion and Modification: If there are issues, discuss in the PR, and the submitter modifies based on feedback.
- Merge Code: After approval, merge into the target branch.

This workflow adds an extra step but significantly improves code quality.

![](https://pic.yupi.icu/1/image-20260105173137083.png)



### Resolving Conflicts

Code conflicts are common in team collaboration. When two people modify the same part of the same file, Git will flag a conflict.

Steps to resolve conflicts: First, pull the latest code `git pull origin develop`, Git will mark the conflict areas. Then manually edit the file to decide which code to keep. After resolving conflicts, test to ensure functionality is normal, then commit the resolved code.

To reduce conflicts, it's recommended to:

1. Frequently pull the latest code, don't stay out of sync for too long
2. Merge features promptly after completion, don't delay
3. Communicate with the team in advance if modifying public files




## 5. Code Review Workflow

Code Review is key to ensuring team code quality.




### Why Do Code Reviews?

Code reviews have many benefits.

First, they can catch potential bugs before code goes live, preventing issues from reaching production. Second, they unify code style, ensuring project code consistency, avoiding situations where everyone's code style is different.

More importantly, code reviews are a great learning opportunity. Reviewers can see others' code thinking, reviewees can get improvement suggestions, and both can learn. Knowing code will be reviewed naturally leads to more careful coding, improving code quality at the source.




### Review Focus Areas

When reviewing code, focus on these aspects:

1. Functional Correctness: Does the code correctly implement requirements? Are there any missed edge cases?
2. Code Quality: Is the code clear and understandable? Is there duplicate code? Are names standardized?
3. Performance Issues: Are there obvious performance issues? Are data structures chosen appropriately?
4. Security Issues: Are there security vulnerabilities? Is user input validated?
5. Test Coverage: Are there sufficient tests? Do tests cover main scenarios?



### Review Techniques

Pay attention to methods during reviews. Don't just say "this is wrong," explain why it's wrong and how to fix it. Use suggestive language, not commanding language. For example, "I suggest optimizing performance here with useMemo" rather than "You must use useMemo here." Of course, exceptions exist if the team has hard requirements.

If there are multiple issues, prioritize. First point out major issues (like bugs, security vulnerabilities), then suggest improvements (like naming, comments).

Reviews aren't one-time; multiple rounds of discussion are possible. First round points out major issues, modify, then review again, confirm before merging.




### Let AI Assist Reviews

You can have AI do preliminary reviews:

```markdown
Please review this code from functional, performance, security, and code quality perspectives:
【Paste code】
```

The AI will give you a detailed review report. But note, AI reviews can't fully replace manual reviews; humans still need to have the final say.



#### Using Cursor's BugBot

Cursor provides a dedicated code review tool called [BugBot](https://cursor.com/cn/bugbot), which automatically scans your code, finds potential bugs, performance issues, and security vulnerabilities, and quickly fixes them.

You can directly use this feature in Cursor, letting AI do preliminary code reviews.

![](https://pic.yupi.icu/1/image-20260105173323498.png)



#### Claude Code Automated Code Reviews

If using Claude Code, you can mark `@.claude` in the code review Pull Request, and Claude will automatically add review suggestions to the `CLAUDE.md` file. Then use GitHub Action for automated updates, gradually accumulating the team's code quality standards and common issues.

This is also recommended by Claude Code's founder, letting code review experience accumulate automatically.




#### Cross-Verification with Multiple AIs

For added safety, have multiple AIs review the same code. For example, have Claude review first, then GPT, and compare their suggestions.

Different AIs might find different issues, cross-verification improves review comprehensiveness.






## 6. Team Collaboration Best Practices

Based on my experience, here are some team collaboration best practices.

💡 This section is mainly for team leaders or managers. If you're not a team manager, just a team member, you can skip this section or just take a look.




### Regular Sync-Ups

Teams should regularly meet to sync progress, like daily stand-ups (5 ~ 10 minutes), weekly meetings (30 ~ 60 minutes).

Stand-ups mainly cover three things: what was done yesterday, what's planned for today, and any issues encountered.

Weekly meetings can delve into technical solutions, share experiences, and plan next week's work.

Besides meetings, tools can also be used for sync-ups. For example, use Jira for task management, WeCom, Feishu, Slack for daily communication, and Notion, Yuque for document sharing.




### Pair Programming

For complex features, try pair programming. Two people develop together, one writes code (Driver), the other reviews and suggests (Navigator). This not only improves code quality but also promotes knowledge sharing.

Honestly, I rarely see companies actually do this because the cost is too high.

But think about it, in Vibe Coding, developing with AI is a kind of pair programming, isn't it?

AI is your programming partner, you propose requirements, it writes code; you review, it improves. This "human-machine pairing" might be more efficient than "human-human pairing."



### Knowledge Sharing

Teams should establish knowledge-sharing mechanisms. You can have someone share recently learned technologies, encountered issues, summarized experiences weekly; or share how to solve a problem with AI, optimize a feature's performance, avoid a common pitfall; or document various technical and business knowledge. This can elevate the entire team's level and avoid repeated mistakes.

Our team uses Yuque knowledge base to share documents. Everyone records issues encountered, experiences summarized, techniques learned, allowing newcomers to quickly get up to speed by reading the knowledge base.

![](https://pic.yupi.icu/1/%E4%BD%BF%E7%94%A8%E7%9F%A5%E8%AF%86%E5%BA%93%E6%95%B0%E9%87%8F.png)



### Building Shared Resources

Teams can build some shared resources, such as:

- Prompt Template Library: Commonly used prompt templates
- Code Snippet Library: Commonly used components and functions
- Issue Solution Library: Encountered issues and solutions
- Best Practices Documentation: Summarized experiences and techniques

These resources help newcomers quickly get up to speed and improve the team's overall efficiency.

You can manage and share