Git for Vibe Coders

Enterprise Onboarding: Connecting to Your Codebase

In an enterprise, traceability is paramount. Every commit must be tied to a specific individual. Using your correct enterprise name and email is non-negotiable.

git config --global user.name "Your Name"
git config --global user.email "your-enterprise-email@company.com"

Don't want to use the terminal? No problem. VS Code will actually prompt you to configure your identity the first time you try to use Git. You can also open the Command Palette (Cmd+Shift+P) and search for "Git: Config" to set these values without touching the terminal.

1. Go to GitHub Settings → Developer settings → Personal access tokens
2. Click Generate new token (classic)
3. Name it descriptively (e.g., "Work Laptop")
4. Set an expiration (90 days recommended)
5. Select scopes: repo and read:org
6. Click Generate token and copy it immediately

git clone https://github.com/Your-Enterprise/your-project.git
# Username: your-github-username
# Password: your-personal-access-token

Storing Your Credentials

# macOS - Store in Keychain (recommended)
git config --global credential.helper osxkeychain

# Windows - Use Windows Credential Manager
git config --global credential.helper manager

# Linux - Store in encrypted file
git config --global credential.helper libsecret

That said, if you're using VS Code, you can skip the PAT setup entirely. VS Code handles GitHub authentication for you -- when you clone a private repo or push for the first time, it opens your browser to sign in. No tokens to generate, copy, or store:

VS Code

The Core Safety Loop: Your "Save Game" for AI Coding

git status is your "heads-up display." The output shows two categories:

The good news? You don't actually need to type git status in the terminal. VS Code shows you all of this visually. Just click the Source Control icon in the Activity Bar (the branch icon on the left sidebar). The badge shows how many files changed, and each file is labeled M (modified), U (untracked), or D (deleted):

VS Code

You can also spot changes right in the editor without opening the Source Control panel. VS Code adds colored indicators in the gutter (the narrow strip to the left of your code): green for added lines, blue for modified lines, and a red triangle for deleted lines. Click any indicator to preview the change inline:

VS Code

Option 1: Stage All (the "trusting" add)

git add .

Option 2: Stage One File (the "surgical" add)

git add src/my_file.py

Option 3: Stage Parts of a File (the "AI-first developer's" add)

Here's how to start an interactive staging session:

git add --patch  # or git add -p

For each hunk, Git asks: y (stage), n (skip), s (split into smaller pieces), q (quit).

The VS Code Way: Visual Staging

This is where VS Code really shines. Instead of typing cryptic y/n/s/q responses in the terminal, you get a beautiful side-by-side Diff Editor. To stage an entire file, just hover over it and click the + button:

VS Code

When you click a file in the Changes list, VS Code opens the Diff Editor -- a side-by-side view showing the old version (left) and new version (right). This makes it easy to review exactly what changed before staging:

VS Code

For even more precision, click a file to open the Diff Editor, then select specific lines and right-click → "Stage Selected Ranges". This is the visual equivalent of git add -p, but far easier to use:

VS Code

git commit -m "feat: Add user authentication endpoint"

The command itself is simple, but the message you write matters more than you might think.

In VS Code, committing is just as simple: type your message in the input box at the top of the Source Control panel and click the Commit button (or press Cmd+Enter). Notice the sparkle icon next to the input -- click it to let AI generate a commit message from your staged changes:

VS Code

Here's the AI commit message feature in action. After staging your changes, click the sparkle icon and Copilot will analyze your diff and write a descriptive message for you:

VS Code

Try It: The Complete Loop

On branch feature/add-auth
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)

	modified:   src/auth.py
	modified:   src/routes.py
	modified:   tests/test_auth.py

Untracked files:
	new file:   src/middleware.py

Parallel Universes: Branching for AI Experiments

First, make sure you're on main and it's up to date. Then create your branch:

git switch -c "feature/my-new-idea"
# Older equivalent: git checkout -b "feature/my-new-idea"

In VS Code, this is even easier. Look at the bottom-left corner of your window -- you'll see the current branch name (e.g., "main"). Click it and you'll get a dropdown where you can switch to existing branches or select "+ Create new branch..." to make a new one:

VS Code

When you click the branch name, VS Code opens a Quick Pick menu listing all your branches. Select "+ Create new branch..." at the top, type a name like feature/my-new-idea, and you're immediately switched to it:

VS Code

Before diving into the commands, here's how the three main remote operations relate to each other:

Fetch downloads without merging. Pull = fetch + merge. Push uploads your commits.

Option 1: The "Safe" Sync (fetch + merge)

git fetch origin        # Download new commits (doesn't apply them)
git merge origin/main   # Merge the updates into your branch

Option 2: The "Easy" Sync (pull)

git pull origin main    # Fetch + merge in one command

VS Code makes syncing visual. Look at the status bar at the bottom of your window -- you'll see small arrows with numbers showing how many commits are incoming (to pull) and outgoing (to push). Click the sync icon (circular arrows) to pull and push in one step:

VS Code

You'll also see a prominent "Sync Changes" button right in the Source Control panel. It shows the exact count of incoming and outgoing commits, so you always know what's about to happen:

VS Code

Once your feature is ready, push your branch to the remote so your teammates can see it:

git push -u origin feature/my-new-idea
# -u links your local branch to the remote branch

Then on GitHub, you'll see a yellow banner: "feature/my-new-idea had recent pushes. Compare & pull request." Click it to create your PR.

Writing a good PR description can feel tedious, but AI tools can help with that too:

You don't even need to leave VS Code to create a PR. Install the GitHub Pull Requests and Issues extension and you can create PRs, review diffs, add comments, approve, and merge -- all without opening your browser:

VS Code

Try It: Branch, Commit, and Push

b4d5e6f (HEAD -> main) Stable feature A
a1b2c3d Initial commit

The "Undo" Toolkit: Reversing AI Mistakes

The fix is simple -- one command wipes the slate clean and takes you back to your last commit:

git restore .              # Discard ALL local changes
git restore src/bad_file.py  # Discard a single file

In VS Code, you don't need the terminal for this. In the Source Control panel, hover over the file you want to discard under "Changes" and click the curved arrow icon. To discard ALL changes at once, click the curved arrow next to the "Changes" header. You can also right-click any file and choose "Discard Changes".

No worries -- unstaging is a safe operation that simply moves a file back out of the staging area:

git restore --staged src/bad_file.py
# Older equivalent: git reset HEAD src/bad_file.py

In VS Code, this is a one-click fix. In the Source Control panel, look under "Staged Changes", hover over the file you want to unstage, and click the − (minus) button. The file moves right back to "Changes":

VS Code

Instead of creating a whole new commit, you can tack the missing file onto the one you just made:

git add src/forgotten_file.py   # Stage the missed file
git commit --amend --no-edit     # Add it to the last commit

# Or just fix the message:
git commit --amend

In VS Code, click the dropdown arrow next to the Commit button and select "Commit (Amend)". This adds your newly staged files to the last commit without needing the terminal. You can also find this under the ... menu → Commit → Commit Staged (Amend).

This is where the nuclear option comes in. A hard reset rolls your branch back as if those commits never happened:

git reset --hard HEAD~3   # Delete last 3 commits + all changes

The "Safer" Resets

The WRONG Solution: You cannot use git reset. It rewrites history that others have, causing repository divergence.

The RIGHT Solution: Create a new commit that undoes the bad commit. This is a revert.

Here's how to create that revert commit in the terminal:

git log --oneline          # Find the hash: a1b2c3d
git revert a1b2c3d         # Create an inverse commit
git push                   # Push the revert

Notice that you're not erasing anything -- you're adding a new commit on top that reverses the damage:

VS Code has this built in too. Open the ... menu in the Source Control panel -- this is your gateway to all advanced Git operations. From here you can access Commit, Changes, Pull, Push, Branch, Stash, and more:

VS Code

For reverting pushed commits, use the Source Control Graph: right-click any commit and select "Revert Commit" to create the inverse commit safely.

You have two flavors of force push, and picking the right one matters a lot:

Before moving to advanced topics, here's a quick-reference matrix summarizing every undo technique and when to use it:

Try It: The Undo Toolkit

On branch feature/experiment
Changes not staged for commit:
	modified:   src/model.py
	modified:   src/utils.py
	modified:   src/config.py

Advanced Scenarios: Managing a Multi-Branch Workflow

The stash is a temporary, private holding area for your dirty changes.

# 1. Stash your changes
git stash save "WIP: refactoring pipeline, AI changes"

# 2. Fix the urgent bug
git switch main
git pull
git switch -c "hotfix/urgent-bug"
# ... fix, test, commit, push, create PR ...

# 3. Return to your work
git switch feature/A
git stash pop

git stash pop re-applies your changes and removes them from the stash. Use git stash apply to keep the stash entry for reuse.

In VS Code, you can do all of this without memorizing commands. Open the ... menu in the Source Control panel -- you'll see a Stash submenu with all the options you need:

VS Code

Choose "Stash (Include Untracked)" to save all your work. When you're ready to come back, go to ... → Stash → "Pop Latest Stash" to restore everything exactly where you left off.

Try It: The Stash Workflow

On branch feature/A
Changes not staged for commit:
	modified:   src/pipeline.py
	modified:   src/transform.py
	modified:   src/loader.py

You have two options for catching up with main, and each tells a different story in your commit history.

VS Code supports both approaches. Use the ... menu in Source Control → "Pull (Rebase)" to rebase instead of merge when pulling. For merging, use the Command Palette (Cmd+Shift+P) → "Git: Merge Branch..." and select the branch to merge.

Try It: Merge vs. Rebase

* f1a2b3c (feature) D - your work
* e5f6a7b (feature) C - your work
| * d4e5f6a (main) F - teammate
| * c3d4e5f (main) E - teammate
|/
* b2c3d4e B - shared history
* a1b2c3d A - shared history

Don't panic -- conflicts look intimidating at first, but they follow a simple pattern. Git inserts special markers into your file to show you exactly where the disagreement is.

The Conflict Markers

<<<<<<< HEAD
// Your AI's change
const x = 10;
=======
// Your teammate's change
const x = 5;
>>>>>>> origin/main

Delete all the markers (<<<, ===, >>>) and edit the code to be the correct final version, then stage and commit.

The VS Code Way (The Superior Way)

Editing conflict markers by hand works, but VS Code makes the whole process much more visual and less error-prone.

VS Code

For complex conflicts with multiple overlapping changes, click "Resolve in Merge Editor" to open the full 3-way view. This gives you the most control over the final result:

VS Code

Try It: Resolving a Merge Conflict

Auto-merging src/model.py
CONFLICT (content): Merge conflict in src/model.py
Automatic merge failed; fix conflicts and then commit the result.

Your AI-Assisted Cockpit: Mastering Git in VS Code

This is your command center. Everything you've learned maps directly to the UI:

Here's what it looks like in action. Press Ctrl+Shift+G (or Cmd+Shift+G on Mac) to open the Source Control panel from anywhere:

VS Code

Below the commit area, you'll find the Source Control Graph -- a visual representation of your commit history and branch structure. This is incredibly helpful for understanding how branches relate to each other:

VS Code

Open any file, then look in the Explorer panel for the "Timeline" pane at the bottom. This shows the complete commit history for that specific file. Click any commit to see a diff, or right-click and select "Restore."

Here's the Timeline in action. Each entry represents a commit that touched this file -- click any entry to see exactly what changed in that commit:

VS Code

VS Code also has built-in Git Blame. Hover over any line of code and you'll see who changed it and when, right in the status bar. For even richer inline annotations on every single line, install the GitLens extension from the VS Code Marketplace -- it's practically essential for professional work:

VS Code

We touched on merge conflicts earlier -- now let's look at the tool that makes resolving them almost enjoyable.

When a conflict occurs, VS Code highlights the conflicting files. Clicking one opens the 3-way editor with three panes:

Here's the merge editor in action. Use the checkboxes next to each change to select which version you want to keep -- or manually edit the Result pane at the bottom for a custom resolution:

VS Code

And if you have GitHub Copilot installed, there's an even easier option. VS Code can use AI to analyze both sides of a conflict and suggest an intelligent resolution. Look for the "Resolve with AI" option in the merge editor:

VS Code

Conclusion: Best Practices for AI-Augmented Teams

This is your new "save game" loop. Follow these 8 steps for every piece of work:

Here's what each step looks like in practice, along with the commands you'll use.

Keep this handy. It covers the most common Git tasks with both the terminal command and the VS Code equivalent, so you can use whichever feels more natural.