Enterprise Onboarding: Connecting to Your Codebase

Every commit you make carries a name and email — your digital signature. Before anything else, Git needs to know who you are.

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 prompt you to configure your identity the first time you commit — answer the prompt and it runs those two commands for you. (There's no palette command for this; the prompt or the terminal are the two paths.)

To see what's already configured — or double-check what you just set — read it back:

git config user.name          # One value
git config --global --list    # Everything you've set globally

While you're here, four more one-time settings pay for themselves many times over:

# New repos start on 'main' (matches GitHub; becomes Git's own
# built-in default in Git 3.0)
git config --global init.defaultBranch main

# Git messages open in VS Code instead of a terminal editor
git config --global core.editor "code --wait"

# First push of a new branch just works - no upstream error
git config --global push.autoSetupRemote true

# When you pull into local commits, replay yours on top
# (you'll meet the alternative in Part 3)
git config --global pull.rebase true

Try It: Introduce Yourself to Git

Meet your constant companion for the rest of this course: the Git Playground — a real Git repository running entirely in your browser. Nothing you type here can touch your actual machine, and most lessons from here on end with one of these, so you can practice each concept the moment you learn it. First exercise: the config commands you just read.

Your company's code lives in a private repository. To access it, you need to prove you're allowed in — and GitHub removed password authentication for Git back in 2021. Today there are two ways to authenticate: over HTTPS with a token, or over SSH with a key pair.

Option 1: HTTPS with a Personal Access Token

A Personal Access Token (PAT) is a generated secret that acts as your password, but with scoped permissions and an expiration date. GitHub now recommends fine-grained tokens, which can be limited to specific repositories:

1. Go to GitHub Settings → Developer settings → Personal access tokens → Fine-grained tokens
2. Click Generate new token and name it descriptively (e.g., "Work Laptop")
3. Set an expiration (90 days recommended)
4. Under Repository access, choose Only select repositories and pick your project
5. Under Permissions, set Contents to Read and write
6. Click Generate token and copy it immediately — you won't see it again

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

Storing Your Credentials

# macOS - usually preconfigured to use the Keychain; if not:
git config --global credential.helper osxkeychain

# Windows - Git for Windows ships with Credential Manager; if not:
git config --global credential.helper manager

# Linux - install Git Credential Manager (git-credential-manager),
# then:
git config --global credential.helper manager
# Lightweight alternative (holds credentials in memory ~15 min):
git config --global credential.helper cache

Option 2: SSH Keys

SSH flips the model. Instead of pasting a secret, you generate a key pair: a private key that never leaves your machine, and a public key you upload to GitHub. Set it up once and every clone, pull, and push just works — no tokens to renew. It's the classic "set it and forget it" choice for a machine you develop on daily.

ssh-keygen -t ed25519 -C "your-enterprise-email@company.com"
# Press Enter to accept the default file location,
# then choose a passphrase (recommended)

# macOS - store the passphrase in your Keychain
eval "$(ssh-agent -s)"
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# Windows (Git Bash) & Linux
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Host *
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/id_ed25519

# macOS
pbcopy < ~/.ssh/id_ed25519.pub

# Windows (Git Bash)
cat ~/.ssh/id_ed25519.pub | clip

# Linux - print it, then copy the output
cat ~/.ssh/id_ed25519.pub

Then go to GitHub Settings → SSH and GPG keys → New SSH key, paste the key, and save. Verify the connection works:

ssh -T git@github.com
# Hi your-username! You've successfully authenticated...

With SSH, repository URLs look different — use the SSH tab of the green Code button when copying a clone URL:

git clone git@github.com:Your-Enterprise/your-project.git
# No username or token prompt - your key authenticates you

Which One Should You Use?

The Modern Shortcut: GitHub CLI

In practice, many developers today never copy a token at all. The GitHub CLI (gh) is GitHub's official command-line tool. Where git talks to the repository, gh talks to GitHub itself — authentication, pull requests, issues, releases — all without leaving your terminal. Download it from cli.github.com or install it with your package manager:

# macOS
brew install gh

# Windows
winget install --id GitHub.cli

# Linux - see cli.github.com for your distro's instructions

Then one command handles the entire authentication setup interactively — including generating and uploading an SSH key if you ask it to:

gh auth login
# Pick HTTPS or SSH, sign in through your browser,
# and it configures Git for you

And if you're using VS Code, it handles GitHub authentication the same way — 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 Expand

Your team's code exists on a remote server. Cloning is the act of bringing the entire project — every file, every branch, every commit in its history — right onto your machine.

To get a copy of the project on your machine, run the clone command with the repository URL your team shared with you:

git clone https://github.com/Your-Enterprise/your-project.git
cd your-project   # The clone lands in a NEW folder named after the repo

That new folder is the repository — specifically, the hidden .git directory inside it holds the entire history, every branch, all of it. Delete .git and you're left with an ordinary folder of files. (And the #1 "Git is broken!" beginner moment: running git commands from the parent folder — check you actually cd'd in.)

The VS Code Way

1. Open VS Code. Click "Clone Repository" on the Welcome page
2. Or use the Command Palette (Cmd+Shift+P / Ctrl+Shift+P) and type Git: Clone
3. Paste the HTTPS URL. VS Code handles authentication automatically
4. Choose a save location, then open the folder

VS Code Expand

One thing to keep in mind after cloning: