Saving Your Work

By the end of this lesson, you’ll know how to inspect your project’s history, undo mistakes, and back up your work to GitHub — completing the full version control toolkit you need as an AI orchestrator.

The Mental Model: Your Project’s Dashboard and Time Machine

In the last lesson, you learned to save snapshots with commits. Now you need two more abilities:

• A dashboard — so you can see what’s happening in your project right now (what changed? what’s saved? what’s pending?)
• A time machine — so you can look at past snapshots and, when needed, go back to one

Git gives you both. Three commands make up your dashboard (status, log, diff), and a couple more give you the time machine (checkout, reset).

Your Dashboard: Three Inspection Commands

git status — What’s Changed Right Now?

git status

This shows:

• Untracked files — new files git doesn’t know about yet
• Modified files — existing files that have changed
• Staged files — files ready to be committed

Run this frequently. It’s your most-used command — the first thing you type when you sit down to work, and the command you check after every AI interaction.

git log — What Have I Committed?

git log --oneline

This shows a list of your commits, newest first:

a1b2c3d Add contact form with validation
e4f5g6h Update homepage hero section
i7j8k9l Initial commit

Each line shows a unique commit ID (the letters/numbers) and your commit message. The --oneline flag keeps it compact.

git diff — What Exactly Changed?

git diff

This shows line-by-line what has changed in your unstaged files. Lines starting with + were added, lines starting with - were removed. If you have already staged changes with git add, use git diff --staged to see those instead.

<h1>Welcome</h1>
<h1>Welcome to My Portfolio</h1>

This is especially useful after an AI tool makes changes. Before you commit, run git diff to review exactly what the AI modified. Think of it as proofreading before you sign off.

Worked Example: Reviewing AI Changes Before Committing

Here’s a realistic scenario. You asked Claude Code to update your project, and now you want to review what it did before saving:

# You already have a clean commit
# Claude Code modified several files
# Step 1: See which files were touched
git status
# modified:   index.html
# modified:   style.css
# new file:   utils.js

# Step 2: See the actual changes
git diff
# Shows line-by-line changes in index.html and style.css
# (New files won't appear in git diff. Stage them first with
#  git add, then use git diff --staged to see their contents.)

# Step 3: Everything looks good — stage and commit
git add .
git commit -m "Add utility functions and update page layout"

# Step 4: Verify the commit is saved
git log --oneline
# f8a9b1c Add utility functions and update page layout
# a1b2c3d Previous commit message...

This review habit — status, then diff, then add and commit — takes 30 seconds and prevents you from accidentally saving broken changes.

Your Time Machine: Undoing Mistakes

One of git’s greatest powers is letting you undo things. Here are the commands you’ll actually need:

Undo Changes to a Specific File (Before Committing)

git restore filename.txt

This reverts the file to its last committed version. The changes are gone.

Undo All Changes Since Last Commit

git restore .

This discards unstaged changes in all tracked files. Use with caution — all uncommitted changes to tracked files are lost. Untracked files (brand-new files the AI created) remain; remove them manually or with git clean -fd.

Undo the Last Commit (Keep the Changes)

git reset --soft HEAD~1

(HEAD means “where we are right now,” and ~1 means “go back one step.” So HEAD~1 = the commit before the current one.)

This undoes the commit but keeps your file changes. Useful when you committed too early or with the wrong message.

Pushing to GitHub

So far everything has been local — saved on your computer only. To back up your work and share it, push to GitHub.

Step 1: Create a GitHub Repository

1. Go to github.com and sign in (create an account if needed)
2. Click the + button, then New repository
3. Name it (e.g., my-project)
4. Keep it Public or Private — your choice
5. Don’t add a README, .gitignore, or license (you already have files)
6. Click Create repository

Step 2: Connect Your Local Project to GitHub

GitHub will show you commands. Copy and run them:

git remote add origin https://github.com/YOUR-USERNAME/my-project.git
git branch -M main
git push -u origin main

Let’s break these down:

• git remote add origin — tells git where to upload (the GitHub URL)
• git branch -M main — renames your branch to “main” (the convention)
• git push -u origin main — uploads your commits to GitHub

Step 3: Future Pushes

After the initial setup, pushing new work is just:

git push

One command. Your code is backed up in the cloud.

The Daily Workflow

Here’s the complete workflow you’ll follow for every project:

# Start of work session
git status                           # Check current state

# Save point before AI work
git add .
git commit -m "Save point: working homepage"

# Make changes (AI tools, manual editing, etc.)
claude                               # or gemini, codex, etc.
> "Add a navigation bar to the site"

# Review what changed
git status                           # See which files were touched
git diff                             # See line-by-line changes

# Save your work
git add .
git commit -m "Add responsive navigation bar"

# Back up to GitHub
git push

Repeat this cycle as many times as you like during a session. Each commit is a save point. Each push is a backup.

Quick Reference

Key Takeaways

• git status is your most-used command. Run it before and after everything — it shows you what git sees.
• Review before committing. Use git diff to check what an AI tool actually changed before you save it.
• Undo is always available. git restore . reverts tracked files to the last commit. git reset --soft HEAD~1 undoes a commit but keeps your files.
• Push to GitHub for backup. After the one-time setup, git push backs up your work in seconds.
• The daily cycle is simple: status, commit, work with AI, review, commit, push. A small set of commands you will repeat: status, diff, add, commit, push.

You now know enough git for 95% of what you’ll do as an orchestrator. There’s much more to git (branches, merging, rebasing), but you can learn those when you need them — and even then, you can ask your AI tool to help you with the commands.