Collaboration — AIGuide

Start here

First, pick the right tool for the job

"Collaborating on files" can mean different things. The best tool depends on what you're sharing and how you work together.

⭐

The short answer

If you're working on a project of code or text files in VS Code — which is exactly your case — Git + GitHub is the best way. It's the worldwide standard, it's free, it works over the internet from anywhere, and it never loses your work. The rest of this page teaches it.

The idea

Why Git + GitHub?

They're two different things that work together:

🌿

Git — the version control system

A tool on your computer that tracks every change to your files as a series of save-points ("commits"). You can see history, undo, and — crucially — merge changes from two people cleanly.

☁️

GitHub — the shared home online

A website that hosts your Git project in the cloud so others can reach it from anywhere. Think of it as the central meeting point your files sync through.

Together they solve the exact problem you described. You don't email files back and forth or worry about being on the same network — you both sync through GitHub over the internet, and Git makes sure nobody's work gets overwritten.

Works from anywhere — any internet connection, any distance. No shared Wi-Fi needed.
Full history & undo — every version is saved; you can always go back.
No overwrites — Git merges two people's edits instead of clobbering one.
Async-friendly — you each work whenever suits you; no need to be online at the same time.
Free & built into VS Code — private repos are free, and VS Code has the buttons built in.

Picture it

The mental model: a hub in the cloud

This is the one diagram to hold in your head. You each keep a full copy of the project on your own machine. GitHub sits in the middle as the shared hub. You push your changes up to it and pull your collaborator's changes down.

Nobody edits the same live file at once — you each edit your own copy, then sync through GitHub.

🔑

Four verbs are all you really need

Clone (get a copy) · Commit (save a checkpoint) · Push (send yours up) · Pull (bring theirs down). Master these and you can collaborate. Everything else is refinement.

One time only

Setup (about 10 minutes)

You only do this once per computer. Your collaborator does the same on theirs.

Create a free GitHub account

Go to github.com and sign up. Your collaborator needs an account too so you can invite them.

Install Git

Download it from git-scm.com (Windows/Mac/Linux). Accept the defaults. This is the engine VS Code drives under the hood.

Install VS Code + the GitHub extension

You already have VS Code. Add the "GitHub Pull Requests" extension from the Extensions panel — it lets you sign in to GitHub and handle reviews without leaving the editor.

Tell Git who you are

Once, in a terminal, so your commits are labelled correctly:

git config --global user.name "Your Name" git config --global user.email "you@example.com"

Use the same email as your GitHub account. In VS Code, run this in the built-in terminal (View → Terminal).

The daily rhythm

The core workflow

Here's the loop you'll repeat forever. Each step shows the button in VS Code and the command it runs underneath (you can use either — the buttons are enough).

Step	What it means	In VS Code	Command
1. Clone	Download a copy of the project from GitHub to your machine	Source Control → Clone Repository	`git clone <url>`
2. Edit	Change files as normal	Just type in the editor	—
3. Stage	Pick which changes go in the next save-point	Click + next to a file	`git add <file>`
4. Commit	Save a labelled checkpoint locally	Type a message → ✓ Commit	`git commit -m "msg"`
5. Push	Send your commits up to GitHub	Sync Changes / Push	`git push`
6. Pull	Bring your collaborator's new commits down	Sync Changes / Pull	`git pull`

🌅

Golden habit

Pull before you start, push when you finish. Pulling first means you build on your collaborator's latest work; pushing at the end shares yours. This one habit prevents most collaboration headaches.

The real thing

Working together without stepping on each other

If you both edit the main version at once, you can clash. The professional pattern avoids that with branches and pull requests — and it's how essentially every software team works.

🌿 A branch

A private line of work split off from main. You make your changes there without disturbing the shared version. Your collaborator works on their own branch.

🔀 A pull request (PR)

When your branch is ready, you open a PR on GitHub: "please merge my branch into main." Your collaborator can review it, comment, and approve — then it merges.

Branch off main, commit freely, then merge back through a reviewed pull request.

A complete walkthrough: you + a friend

You create the repo & invite them

On GitHub, create a new repository (make it Private). Open Settings → Collaborators → Add people and enter your friend's GitHub username. They get an invite email.

Both clone it

Each of you runs git clone <url> (or VS Code's Clone Repository). Now you both have a full local copy.

Make a branch for your task

Before editing: git checkout -b add-login. Your friend does the same with their own name, e.g. git checkout -b fix-header.

Work, commit, push your branch

Edit → commit → git push -u origin add-login. Your branch now lives on GitHub, separate from main.

Open a pull request

GitHub shows a "Compare & pull request" button. Open it, describe your change, and request your friend as reviewer.

Review, approve, merge

Your friend reads the diff, comments if needed, approves, and clicks Merge. Your work is now part of main.

Everyone pulls main

Both of you run git checkout main then git pull to get the newly merged work. Repeat from step 3 for the next task.

No command line needed

Doing it all inside VS Code

VS Code has Git built in, so you can do everything above with buttons. The Source Control panel (the branch icon in the left bar, or Ctrl+Shift+G) is your home base.

📥Clone: Command Palette (Ctrl+Shift+P) → Git: Clone, paste the GitHub URL.
🌿New branch: click the branch name in the bottom-left status bar → Create new branch.
➕Stage & commit: in Source Control, hover a file and click +, type a message, click ✓ Commit.
🔄Sync: the Sync Changes button pushes your commits and pulls theirs in one click.
🔀Pull requests: the GitHub extension adds a Pull Requests view to create, review, and merge PRs without leaving the editor.

Source Control

Changes

auth.tsM +

login.cssU +

Add login form validation

✓ Commit

🔄 Sync Changes ↑2 ↓1

Don't panic

Merge conflicts, demystified

A merge conflict happens only when you and your collaborator change the same lines of the same file. Git can't guess who's right, so it asks you. It's normal and fixable — not a disaster.

Git marks the clash right in the file like this:

<<<<<<< HEAD const title = "Welcome back"; # your version ======= const title = "Hello again"; # their version >>>>>>> fix-header

To resolve it, you just decide what the final lines should be and delete the <<<, ===, >>> markers. VS Code makes this a click:

🟩It shows buttons above the conflict: Accept Current, Accept Incoming, Accept Both, or Compare.
✍️Or edit the lines by hand to blend both. Then stage the file and commit — conflict resolved.

🛡️

How to avoid most conflicts

Pull often, keep branches short-lived, and — where you can — agree who owns which files. Conflicts shrink to almost nothing when you sync frequently instead of hoarding changes for days.

The real-time option

Want to edit together live? Use Live Share

Git is asynchronous — great for working on your own schedule. But sometimes you want to sit "shoulder to shoulder" in the same file at the same time, like Google Docs for code. That's VS Code Live Share.

👥

What it does

Install the Live Share extension, click Share, and send the link. Your collaborator sees your project, your cursors move together, and you can even share a terminal and a running server — no setup on their end.

⚖️

The trade-off

It's a live session, not permanent storage. When it ends, the shared view goes away. Use it alongside Git: Live Share for pairing in the moment, GitHub for saving and syncing the actual work.

🤝

Best of both

Many people pair over Live Share to solve a tricky bit together, then whoever's hosting commits and pushes to GitHub so the result is saved for everyone. They're partners, not rivals.

The full picture

All the options compared

Tool	Best for	Style	Verdict for you
Git + GitHub	Code & text projects	Async, versioned	⭐ The recommended choice — exactly your use case.
VS Code Live Share	Live pair programming	Real-time	Great add-on for working together in the moment.
GitHub Codespaces	A shared cloud dev machine	Cloud IDE	Handy if setups differ; builds on GitHub.
Google Drive / Dropbox	Documents, images, media	File sync	Fine for non-code files; poor for code (no real merging).
OneDrive	Office docs on Windows	File sync	Same as above — not for a code project.
Email / USB / chat	One-off single files	Manual	❌ Avoid for anything ongoing — versions get lost.

Good habits

Safety & good habits

✓ Do

✓Use a .gitignore to keep junk and secrets out of the repo (e.g. node_modules/, .env).
✓Write clear commit messages — "Fix login redirect", not "stuff".
✓Pull before you start, push when you finish.
✓Keep private repos private until you intend to share publicly.

✗ Avoid

✗Never commit passwords, API keys, or tokens. Once pushed, treat them as leaked.
✗Don't commit huge binaries (videos, big datasets) — Git handles text, not gigabytes.
✗Don't force-push shared branches — it can erase a collaborator's work.

🔑

A note on sign-in

GitHub sign-in and any credentials are things you should enter yourself in your browser or VS Code — never paste tokens into files or share them in chat. If you get stuck on authentication, GitHub's own docs walk you through it safely.

Keep this handy

Command cheat sheet

The buttons in VS Code cover all of these — but here's what runs underneath, for when you want the terminal.

# one-time per project git clone <url> # get your own copy from GitHub # the everyday loop git pull # bring down the latest before you start git checkout -b my-feature # start a branch for your task git add . # stage all your changes git commit -m "What I did" # save a checkpoint git push -u origin my-feature # send your branch to GitHub # then open a Pull Request on github.com, get it reviewed & merged # helpful anytime git status # what's changed? git log --oneline # history of commits git checkout main && git pull # get back to the latest shared version

Your first move

Try it in 15 minutes

Create a free GitHub account, make a private test repo, invite your collaborator, and both clone it in VS Code. Push one small change each and watch it appear on the other side. That single loop is remote collaboration — everything else builds on it.

Open GitHub VS Code + GitHub docs ↗