Mastering Remote Git Collaboration: The Right Way for Team Development

Remote Repository Basics

Clone and View Remotes

# Clone a remote repository
git clone https://github.com/user/repo.git

# Clone to a specific directory
git clone https://github.com/user/repo.git my-project

# List configured remotes
git remote -v
# origin  https://github.com/user/repo.git (fetch)
# origin  https://github.com/user/repo.git (push)

# Show detailed information about a remote
git remote show origin

# Add a new remote named upstream
git remote add upstream https://github.com/another/repo.git

Push and Pull

# Push a local branch to the remote
git push origin main

# Push a new feature branch and set upstream
git push -u origin feature/login

# Pull remote updates (fetch + merge)
git pull origin main

# Fetch only (no merge)
git fetch origin

# List remote branches
git branch -r

# List all branches (local + remote)
git branch -a

Standard Team Collaboration Process

Full Workflow

# 1. Pull latest code
git checkout main
git pull origin main

# 2. Create a feature branch
git checkout -b feature/payment

# 3. Develop and commit
git add .
git commit -m "feat: add payment feature"

# 4. (Optional) Sync with main
git fetch origin
git rebase origin/main   # or git merge

# 5. Push the feature branch
git push -u origin feature/payment

# 6. Open a Pull Request, undergo code review, then merge

# 7. Delete the local branch
git checkout main
git pull origin main
git branch -d feature/payment

Conflict Resolution in Practice

Typical Conflict Scenarios

Scenario A: Two developers edit the same line of the same file.
Scenario B: You edit a file while another developer has already edited and pushed it.
Scenario C: Pulling brings remote changes that conflict with your local modifications.

Step‑by‑Step Conflict Resolution

# 1. Detect the conflict
git pull origin main
# CONFLICT in src/OrderService.java

# 2. Inspect conflicted files
git status
# both modified: src/OrderService.java

# 3. Manually edit the file, resolve the <<<<<<<<< HEAD>> and <<>>>>>>> markers.

# 4. Mark the file as resolved
git add src/OrderService.java

# 5. Commit the merge result
git commit -m "merge: resolve conflict"

Conflict‑Resolution Tools

# Use Git's built‑in mergetool
git mergetool

# IDE integrations (recommended)
# IDEA: VCS → Git → Resolve Conflicts
# VS Code: click "Accept Current" or "Accept Incoming"

# Quickly keep one side
git checkout --ours src/OrderService.java   # keep local version
git checkout --theirs src/OrderService.java # keep remote version

Pull Request Workflow

What a Pull Request Is

A Pull Request (PR) is the core mechanism for code review and collaboration.

Complete PR Creation Steps

# 1. Finish development and push the feature branch
git push -u origin feature/payment

# 2. Create a PR on GitHub/GitLab (base: main, compare: feature/payment)

# 3. Fill PR details
# Title example: feat: add payment feature
# Description: implement WeChat Pay and Alipay

# 4. Wait for review approval

# 5. After merge, clean up the branch
git checkout main
git pull origin main
git branch -d feature/payment

PR Naming Convention

# PR title format
<type>(<scope>): <subject>

# Examples
feat(payment): add WeChat Pay
fix(order): fix concurrent order‑status update
docs(readme): update deployment guide

# PR description template (optional sections)
## Feature description
Briefly explain what the PR does

## Changes
- Add PaymentService
- Modify OrderController
- Add unit tests

## Test verification
- [ ] Unit tests pass
- [ ] Manual testing passes

Branch Protection Rules

Common Protection Settings (GitHub)

# Protect the main branch
Require:
- CI/CD checks to pass
- At least 1 reviewer approval
- Direct pushes are prohibited
- Branch must be up‑to‑date with main before merging
- (Optional) Enforce linear history

Configuring Protection

# Settings → Branches → Add rule
# Enter "main" and enable:
- Require pull‑request reviews before merging
- Require status checks to pass before merging
- Require branches to be up to date
- Disallow bypassing these settings

Common Remote Operations Scenarios

Sync Remote main to a Local Branch

# Method 1: merge (recommended)
git checkout feature
git merge origin/main

# Method 2: rebase (keeps history linear)
git fetch origin
git rebase origin/main

Cancel a Pushed Commit

# Safe way: revert the latest commit
git revert HEAD
git push origin main

# Revert a specific commit
git revert <commit-hash>
git push origin main

Delete a Remote Branch

# Delete remote feature branch
git push origin --delete feature/payment

# Delete local branch
git branch -d feature/payment

Inspect Remote Repository Information

# Show remote URLs
git remote -v

# Show commit history of a remote branch
git log origin/main --oneline

# Show differences between local and remote main
git log main..origin/main

Frequently Asked Questions and Pitfalls

Difference Between git pull and git fetch

# git fetch  – download only, no merge
# git pull    – fetch + merge

# Recommended workflow:
git fetch origin
git diff origin/main   # review changes
git merge origin/main   # merge after confirming

Push Rejected Due to Remote Changes

# Error: ! [rejected] main -> main (fetch first)
# Reason: remote has new commits

# Fix:
git pull origin main   # integrate remote changes
# Resolve any conflicts
git push origin main

Accidentally Pushed Sensitive Information

# Immediate steps
1. Notify team members
2. Rotate keys/passwords
3. Clean Git history (if repository is private)

# Force‑remove the file from history (use with caution)
git filter-branch --force --index-filter "git rm --cached --ignore-unmatch path/to/secret.txt" --prune-empty --tag-name-filter cat -- --all
git push --force

Quick Command Reference

# Clone a repository
git clone <url>

# Show remote URLs
git remote -v

# Push a branch
git push origin <branch>

# Pull and merge
git pull origin <branch>

# Fetch only (no merge)
git fetch origin

# List remote branches
git branch -r

# Delete a remote branch
git push --delete <remote> <branch>