// ai-starter-guide v2

From Zero to
Actually Using AI

No fluff. No overwhelm. Steps explained in plain English — built for someone who already thinks in databases.

GitHub — code home
Claude — AI brain
Supabase — database
progress 0% complete
📂
GitHub — What It Actually Is
The full mental model, built on concepts you already own
📖 the story first Imagine you're working on a database schema for a client. You make a change, something breaks, and now you need to go back to how things looked on Tuesday. If you didn't save a backup, you're rebuilding from memory. GitHub is the system that makes sure that never happens — for code files. Every version. Every change. Every person who touched it. All of it, forever, perfectly organized.

Git is the software that tracks changes on your computer. GitHub is the website that stores and shares that history online. Same relationship as PostgreSQL running locally vs. a hosted database server you can access from anywhere.

// the database engineer translation table

GitHub Term Database Equivalent What It Means in Practice
Repository (repo) Database / schema A folder holding your entire project — all files, all history. A database that stores code instead of rows.
Commit Transaction + audit log A saved snapshot with a timestamp and message. "At 2pm Tuesday my code looked like this." You can restore to any commit exactly like restoring a backup.
Branch Staging schema / test env A parallel copy where you experiment without touching the live version. Nothing breaks production while you work.
main branch Production database The official live version. Changes come in through branches after being tested — not directly.
Clone Full schema export / pg_dump Download the entire repo — all files and full history — to your computer with one command.
Pull Sync from upstream Someone else made changes to the remote repo. Pull brings those into your local copy.
Push Replicate to remote Send your committed changes up to GitHub — backed up, visible to collaborators, accessible everywhere.
Pull Request (PR) Schema change + peer review A formal proposal to merge your branch into main. Shows the diff, allows review, requires approval before touching production.
Merge Apply migration Accept the PR and fold the branch into main. Branch is usually deleted after — it served its purpose.
Merge conflict Concurrent write conflict Two people edited the same line. Git can't auto-resolve — asks you to pick the winner. Same as two transactions writing the same row.
Fork Schema copy for independent dev Your own copy of someone else's public repo. Experiment freely without affecting theirs.
.gitignore Excluded / redacted fields A file telling Git what to never track. API keys, passwords, temp files go here. Without it, secrets end up on GitHub for everyone to see.
🗄️ why this matters for ai Claude can read your entire GitHub repo and work with it. When you share a repo link, Claude has full context — like giving a consultant your complete database schema before asking them to optimize a query. The more organized your repo, the more useful Claude becomes.

// the flow, visualized

git clone
download
→
edit files
make changes
→
git add .
stage
→
git commit
snapshot
→
git push
sync to github
▶

Git and GitHub for Beginners Tutorial — Kevin Stratvert

Walks through every concept shown above — all on screen, step by step. Installation, commits, branching, collaborating. Widely recommended as the clearest beginner walkthrough available. Watch this alongside Phase 2 hands-on steps.

YouTube ~30 min Beginner-friendly Highly recommended
⌨️
GitHub — Hands-On Setup
Install Git, create a repo, commit, push — all the way through

Reading about GitHub is like reading about swimming. At some point you have to get in the water. These steps take you from zero to a working commit pushed to GitHub — in under an hour.

⚡ git vs github — install both Git = software on your computer. Runs when you type commands in your terminal.
GitHub = the website (github.com). Your online account where repos live.

Install Git first, then create your GitHub account. Once both exist, Git on your machine talks to GitHub the website.

// step-by-step: your first real commit

1
Install Git on your computer

Mac: Open Terminal, type git --version. If missing, Mac prompts to install developer tools — click install, wait 2 min.
Windows: Download from git-scm.com, run installer, accept defaults. You'll get "Git Bash" — use that as your terminal.
Verify: git --version should return a version number, not an error.

2
Tell Git who you are (one-time setup)

Every commit you make will carry your name and email — like an audit log author field. Run once:

# Run these once. They're stored permanently on your computer.
git config --global user.name "Your Name"
git config --global user.email "you@email.com"
3
Create a GitHub account and your first repository

Go to github.com → create a free account. Click the green "New" button. Name it my-first-ai-project. Check "Add a README file." Click Create repository.

You now have an empty project on GitHub — like creating a new database with one table (the README) already in it.

4
Clone the repo to your computer

On your repo page, click the green "Code" button → copy the HTTPS URL. Then in your terminal:

# Downloads the full repo — all files + history — to a new local folder
git clone https://github.com/YOUR-USERNAME/my-first-ai-project.git

# Navigate into it
cd my-first-ai-project

You have a local copy. Changes here don't affect GitHub until you push — same as a local database that hasn't replicated yet.

5
Make a change and check status

Open README.md in any text editor. Add one line. Save. Then:

# See what changed — Git's diff report
git status
modified: README.md
6
Stage and commit your change

Staging = choosing which changes to include in this commit. Think: selecting rows for a batch INSERT before executing.

# Stage everything (dot = all modified files)
git add .

# Commit with a message — this is your audit log entry
git commit -m "update README with my first change"
[main abc1234] update README with my first change
1 file changed, 1 insertion(+)

That commit is saved in local history forever. You can always restore to this exact state.

7
Push to GitHub
git push
Enumerating objects: 3, done.
To https://github.com/YOUR-USERNAME/my-first-ai-project.git
abc1234..def5678 main → main

Refresh your GitHub repo in the browser. Your change is live — with your message, your name, timestamp. First entry in your transaction log.

8
View your commit history

On GitHub click "commits" at the top of your repo. Full audit trail — every change, author, timestamp, and a link to see the exact diff. In the terminal:

git log --oneline
def5678 update README with my first change
abc1234 Initial commit

// the daily command loop — memorize this

STEP 1
edit files
Make changes to your code
STEP 2
git add .
Stage everything modified
STEP 3
git commit -m
Snapshot with a message
STEP 4
git push
Sync to GitHub
🧠
Claude — Your AI Thinking Partner
Set it up, talk to it right, use it with your repos

Claude is made by Anthropic. You'll use it for writing, coding, debugging, and thinking through problems. The quality of what you get back depends almost entirely on how well you frame what you're asking.

🗄️ database analogy Claude is a query engine. A well-formed prompt is a well-written query — right context, right filters, clear intent. A vague prompt is SELECT * with no WHERE clause. You'll get results. They just won't be what you needed. Garbage in, garbage out — same rule applies.
▶

Jack Roberts — Claude Code & AI Workflow Builds

Shows his screen and builds actual things with Claude — not theory. Great for seeing how Claude fits into a complete development workflow, not just answering questions in isolation.

YouTube Claude Code focus Real builds
🐘
Supabase — Your Database in the Cloud
It's literally PostgreSQL. You already know this.

This is the easiest step for you. Supabase is hosted PostgreSQL with a web UI, REST API, auth, and file storage built on top. If you can write SQL, you can use Supabase on day one.

✅ the best news Supabase runs on real PostgreSQL — not a "compatible" approximation. Full Postgres. Views, functions, triggers, jsonb, window functions, EXPLAIN ANALYZE — everything you already know works identically. You are not starting from scratch here.
🔌 claude + supabase = official integration Anthropic and Supabase have an official connector. You can connect Claude directly to your Supabase project and ask it to analyze your schema, write migrations, generate API code, or find query performance issues. Your database expertise becomes a superpower — most beginners can't reason about database structure. You can.
🔗
Connect Everything Together
Claude writes code that lives in GitHub and talks to Supabase

This is where the three tools stop being separate and become a system. Goal: have Claude write code that connects to Supabase, committed to GitHub. One loop, all three tools.

⚡ what you're building A small Python script that connects to your Supabase database, inserts a row, and reads it back. Not an app. Not a product. Just a proof that the stack is wired and you understand how it flows. Think of it as your SELECT 1 — just confirming everything's alive.
🚀
Build Something Real
Pick a project, ship it, do it again

The only way to learn this stack is to build something that matters to you. Not a tutorial. Not a copy-paste. Something you'd actually use. Three ideas sized for exactly where you are right now.

01

SQL Query Journal

Paste queries, add notes about what they do and why, search them later. Claude writes the UI. Supabase stores them. Uses your expertise immediately.

02

AI Schema Reviewer

Paste a schema into a form → Claude analyzes for normalization, missing indexes, naming issues → results saved to Supabase. Turns your domain skills into a tool.

03

Learning Tracker

Log what you learned each day, what you built, what questions remain. Claude summarizes your week. Simple Supabase backend. Low stakes, high learning.

▶

Nick Saraev — AI Automation & Real System Builds

Builds real things in public — no theory, working systems. His Claude Computer Use content shows AI actively controlling tools, running code, and building workflows. Watch when you're ready to go beyond the basics.

YouTube AI Automation Advanced builds

You're Not Starting From Zero

You have something most AI beginners don't — a deep understanding of data. How it's structured, how it flows, how systems break when the structure is wrong. That's the foundation everything in AI is built on. The tools are just tools. You already know how to think.

// progress saves automatically in your browser