The AI Building Course

You are coaching me through Project 02 of the AI Building Course, a Wordle-style word
game. I am a beginner. I may not know what a terminal, a package or a variable is.
Explain things as you go, in plain English, and don't assume I know a term just because
you used it a moment ago.

This project has NO API key and NO account - nothing to sign up for, nothing that can
cost me money. We are working in the folder I have open right now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `02-Wordle-Clone` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html, app.js,
styles.css, package.json, package-lock.json, README.md, PROMPTS.md, STUDENT-PROMPT.md and
.gitignore sitting right here. I should NOT end up with a nested `ai-building-course`
folder or a nested `02-Wordle-Clone` folder.

Use whichever method works on my machine - check what I actually have before choosing:

  - If `git` is available: clone the repo shallowly into a temporary subfolder, move the
    contents of `02-Wordle-Clone` into my current folder, then delete the temporary
    subfolder entirely (including its .git folder - I don't want your repo's git history
    in my project).

  - If `git` is missing: download the tarball with curl and extract it. Both `curl` and
    `tar` are built into Windows 10+ and macOS.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz

  - If both fail, tell me exactly what failed and what you'd like me to install. Do not
    silently give up, and do not hand-write the game from memory - I want the real files
    from the repo.

If my folder already has these files (maybe I ran this before), don't re-download over
the top. Tell me what's already here and move on.

When the files are here, read the README.md you just downloaded before continuing.

STEP 2 - CHECK MY SETUP

Check that Node.js is installed and is version 20 or newer (`node --version`).

If it is missing or too old, stop and tell me to install the LTS build from
https://nodejs.org. Warn me that a new terminal TAB is not enough: VS Code and Claude
Code keep the settings they had when they launched, so I have to fully quit and reopen
them (and if it still fails after that, restart the computer). Don't try to install Node
for me and don't try to work around it.

On Windows, if `npm` or `npx` fails with "npm.ps1 cannot be loaded because running
scripts is disabled on this system", that is PowerShell's default script policy, not a
broken install. Tell me I can either use `cmd` instead, or run
`Set-ExecutionPolicy -Scope CurrentUser RemoteSigned` once in PowerShell and answer Y.

STEP 3 - THE CONCEPT (this is what Project 02 is really about)

Before we run anything, explain what this project teaches, in plain English: a game is
just a set of rules written down as code, plus a little bit of hidden "state" the program
remembers as I play.

Point me at three things in the code I just downloaded, and explain each in one or two
sentences:
  - The secret word: in `app.js`, `secretWord` is picked at random and kept in a variable.
    Everything else is comparing my guesses to it.
  - The state: the variables `currentRow`, `currentTile`, `gameOver` and `guesses` at the
    top of `app.js`. Every keypress changes one of them.
  - The clever bit: the `getColors` function, which decides green/yellow/grey for each
    tile. Tell me it works in TWO passes (greens first, then yellows) and ask me to guess
    why - the answer is repeated letters, and it's worth me actually thinking about before
    you tell me.

Keep this short - a few sentences each, not a lecture. The point is that I look at real
code and see it isn't magic.

STEP 4 - RUN IT

Run `npm install` in my folder. Warn me first that it prints a lot of text and takes a
minute or two, and that this is normal. It installs into this folder only. It will end
with some "vulnerability" warnings, possibly in red - tell me those are harmless noise
from inside the Netlify tool and NOT to run `npm audit fix --force`.

Then start it with:

    npx netlify dev

Do not install the Netlify CLI globally - `npm install` already put a copy in this folder.
If it asks me to log in to Netlify or link a site, tell me I can skip that.

IMPORTANT, so I don't think it's broken when it isn't: on the FIRST run, netlify prints
"Local dev server ready" BEFORE it is truly ready - it sets one more thing up in the
background. If the page is blank or odd for a few seconds, warn me to wait up to 30
seconds and refresh rather than changing anything. It only happens on the very first run.

Tell me to open http://localhost:8888 and play a round: type a 5-letter word, press Enter,
watch the tiles colour. If port 8888 is busy, use `npx netlify dev --port 8899` and tell
me the new address.

STEP 5 - MAKE IT MINE

Once it works:
  - Show me the `VALID_WORDS` list at the top of `app.js` and get me to add a word to it
    (a real 5-letter word). Explain that it's both the answers and the allowed guesses,
    so my new word can now come up.
  - Walk me through ONE run of `getColors` with a specific guess and secret word, so I can
    see the two-pass colouring actually happen.
  - Point me at PROMPTS.md for the bonus challenges.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps. Keep explanations short. When
you run a command, say what it does before you run it. If something doesn't match what
this prompt describes, tell me plainly instead of improvising around it.

You are coaching me through Project 03 of the AI Building Course, a personal portfolio
website that I am going to DEPLOY to the real internet. I am a beginner. I may not know
what a terminal, a package, or "deploying" means. Explain things as you go, in plain
English, and don't assume I know a term just because you used it a moment ago.

This project has NO API key and costs nothing. The one new thing it teaches is deploying:
putting my site on the internet with a public web address. We are working in the folder I
have open right now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `03-Portfolio-Website` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html, script.js,
styles.css, package.json, package-lock.json, README.md, PROMPTS.md, STUDENT-PROMPT.md and
.gitignore sitting right here. I should NOT end up with a nested `ai-building-course`
folder or a nested `03-Portfolio-Website` folder.

Use whichever method works on my machine - check what I actually have before choosing:

  - If `git` is available: clone the repo shallowly into a temporary subfolder, move the
    contents of `03-Portfolio-Website` into my current folder, then delete the temporary
    subfolder entirely (including its .git folder).

  - If `git` is missing: download the tarball with curl and extract it. Both `curl` and
    `tar` are built into Windows 10+ and macOS.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz

  - If both fail, tell me exactly what failed and what you'd like me to install. Do not
    silently give up, and do not hand-write the site from memory - I want the real files.

If my folder already has these files, don't re-download over the top. Tell me what's here
and move on.

When the files are here, read the README.md you just downloaded before continuing.

STEP 2 - CHECK MY SETUP

Check that Node.js is installed and is version 20 or newer (`node --version`).

If it is missing or too old, stop and tell me to install the LTS build from
https://nodejs.org. Warn me that a new terminal TAB is not enough: VS Code and Claude
Code keep the settings they had when they launched, so I have to fully quit and reopen
them (and if it still fails after that, restart the computer). Don't try to install Node
for me and don't try to work around it.

On Windows, if `npm` or `npx` fails with "npm.ps1 cannot be loaded because running
scripts is disabled on this system", that is PowerShell's default script policy. Tell me I
can either use `cmd` instead, or run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`
once in PowerShell and answer Y.

STEP 3 - RUN IT LOCALLY (the private rehearsal)

Run `npm install` (warn me it prints a lot and takes a minute; the vulnerability warnings
at the end are harmless noise - do NOT run `npm audit fix --force`).

Then `npx netlify dev`. It serves the site at http://localhost:8888. If it offers to log
me in to Netlify, tell me to skip it - I don't need an account just to preview.

Warn me about the first-run timing: netlify prints "ready" a few seconds before it truly
is, so if the page is blank, wait up to 30 seconds and refresh. Only happens once.

Have me open the site and look at it. Then explain, in one or two sentences, that this
`localhost` address only works on MY computer - which is exactly why the next step matters.

STEP 4 - THE CONCEPT + DEPLOY (this is what Project 03 is about)

Explain the concept in plain English before we do it: `localhost` means "this computer
only". Deploying copies my files onto a server that's always online and gives them a
public web address, so anyone with the link can open my site. That's the difference
between a project and a published project.

Then coach me through deploying with Netlify Drop, which is the simplest way:

  1. Tell me to go to https://app.netlify.com/drop in my browser.
  2. Tell me to drag my project FOLDER onto that page - but WARN me first not to include
     the `node_modules` folder (it's huge and unnecessary for a plain HTML site, and
     Netlify Drop works best under 50MB). The cleanest approach: tell me to drag just the
     three files - index.html, styles.css, script.js - or a copy of the folder with
     node_modules deleted.
  3. Tell me Netlify will give me a live URL in a few seconds, and that to keep/manage the
     site I can sign up for a free account (no card).

IMPORTANT: the drag-and-drop is something I do myself in my browser - you cannot do it for
me, and you should NOT try to deploy on my behalf, log into Netlify, or use any Netlify
account. Your job is to explain each step and tell me what I should see. Wait for me to
tell you it worked and paste my live URL.

If I would rather use the command line, the alternative is `npx netlify deploy` then
`npx netlify deploy --prod` from the project folder (it opens a browser to log me in) -
but Netlify Drop is the easier first deploy, so steer me there unless I ask.

STEP 5 - MAKE IT MINE

Once my site is live:
  - Congratulate me - I have a real website on the internet.
  - Help me replace the placeholder content in index.html with my real name, about-me,
    projects (including the roast generator and Wordle from earlier), and real GitHub /
    LinkedIn links.
  - Explain how to redeploy: drag the folder again, or `npx netlify deploy --prod`.
  - Point me at PROMPTS.md for more.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps. Keep explanations short. When
you run a command, say what it does before you run it. Never deploy on my behalf or touch
a Netlify account - deploying is the thing I'm here to learn to do myself. If something
doesn't match what this prompt describes, tell me plainly instead of improvising.

You are coaching me through Project 04 of the AI Building Course, a live cryptocurrency
price dashboard. I am a beginner. I may not know what a terminal, a package, an API, or a
variable is. Explain things as you go, in plain English, and don't assume I know a term
just because you used it a moment ago.

This project has NO API key and NO account - and that is the whole point of it. We are
working in the folder I have open right now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `04-Crypto-Dashboard` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html, script.js,
styles.css, package.json, package-lock.json, README.md, PROMPTS.md, STUDENT-PROMPT.md and
.gitignore sitting right here. I should NOT end up with a nested `ai-building-course`
folder or a nested `04-Crypto-Dashboard` folder.

Use whichever method works on my machine - check what I actually have before choosing:

  - If `git` is available: clone the repo shallowly into a temporary subfolder, move the
    contents of `04-Crypto-Dashboard` into my current folder, then delete the temporary
    subfolder entirely (including its .git folder).

  - If `git` is missing: download the tarball with curl and extract it. Both `curl` and
    `tar` are built into Windows 10+ and macOS.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz

  - If both fail, tell me exactly what failed. Do not hand-write the app from memory - I
    want the real files.

If my folder already has these files, don't re-download. Tell me what's here and move on.

When the files are here, read the README.md you just downloaded before continuing.

STEP 2 - CHECK MY SETUP

Check that Node.js is installed and is version 20 or newer (`node --version`).

If it is missing or too old, stop and tell me to install the LTS build from
https://nodejs.org. Warn me that a new terminal TAB is not enough: VS Code and Claude
Code keep the settings they had when they launched, so I have to fully quit and reopen
them (and if it still fails after that, restart the computer). Don't try to install Node
for me and don't try to work around it.

On Windows, if `npm` or `npx` fails with "npm.ps1 cannot be loaded because running
scripts is disabled on this system", that is PowerShell's default script policy, not a
broken install. Tell me I can either use `cmd` instead, or run
`Set-ExecutionPolicy -Scope CurrentUser RemoteSigned` once in PowerShell and answer Y.

STEP 3 - THE CONCEPT (this is what Project 04 is really about)

Before we run anything, explain the big idea, because this project is the deliberate
OPPOSITE of Project 01:

  - An API is one program asking another for something. Project 01 asked an AI to write a
    roast, and that cost money, so it needed a secret key - which had to be hidden on a
    server so visitors couldn't steal it.
  - THIS project asks CoinGecko for crypto prices. That is free and public - no key, no
    account, no secret. And here's the key insight: because there is no secret to protect,
    the code can call the API straight from the browser. There is no server-side function
    in this project at all. Same idea (call an API), opposite architecture. The deciding
    question is always: is there a secret?
  - The one catch: a free public API limits how OFTEN it answers (a "rate limit"). Ask too
    fast and it returns HTTP 429, which means "slow down", not "broken". Point me at the
    error-handling in script.js and tell me that's what most of the code is actually for.

Keep this short - a few sentences each. The point is that I understand WHY 01 and 04 are
built so differently.

STEP 4 - RUN IT

Run `npm install` (warn me it prints a lot and takes a minute; the vulnerability warnings
at the end are harmless noise - do NOT run `npm audit fix --force`).

Then `npx netlify dev`. It serves the dashboard at http://localhost:8888. If it offers to
log me in to Netlify, tell me I can skip it. Reassure me that netlify printing "No app
server detected / using simple static server / unable to determine public folder" is
normal for a plain static site. And warn me about the first-run timing: it prints "ready"
a few seconds early, so if the page is blank, wait up to 30 seconds and refresh.

Tell me to open http://localhost:8888 and watch the prices load. Then have me open the
browser's DevTools console (F12 on Windows, Cmd+Option+I on Mac) and look at the "API
Response" the code prints - that's the real live data. If port 8888 is busy, use
`npx netlify dev --port 8899`.

If the prices don't appear and a "data's busy, wait a minute" message shows instead, tell
me that's the rate limit, not a bug - especially likely on shared wifi - and it'll fill in
on its own.

STEP 5 - MAKE IT MINE

Once it works:
  - Show me the `API_URL` line at the top of script.js and get me to change the list of
    coins (the `ids=` part) - swap one out or add one like `litecoin`.
  - Walk me through the error-handling in script.js and explain what each case (429, other
    errors, no internet) does, so I see that "handle the failure" is real work.
  - Point me at PROMPTS.md for the bonus challenges.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps. Keep explanations short. When
you run a command, say what it does before you run it. If something doesn't match what
this prompt describes, tell me plainly instead of improvising around it.

You are coaching me through Project 05 of the AI Building Course, a habit streak tracker.
I am a beginner. I may not know what a terminal, a package, or a variable is. Explain
things as you go, in plain English, and don't assume I know a term just because you used
it a moment ago.

This project has NO API key and NO account - nothing to sign up for. Its whole point is
localStorage: saving data in the browser so it survives a refresh. We are working in the
folder I have open right now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `05-Habit-Tracker` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html, app.js,
styles.css, package.json, package-lock.json, README.md, PROMPTS.md, STUDENT-PROMPT.md and
.gitignore sitting right here. I should NOT end up with a nested folder.

Use whichever method works on my machine:
  - If `git` is available: clone shallowly into a temp subfolder, move the contents of
    `05-Habit-Tracker` up, then delete the temp subfolder (including its .git).
  - If `git` is missing: download and extract the tarball with curl/tar.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz
  - If both fail, tell me exactly what failed. Do not hand-write the app from memory.

If my folder already has these files, don't re-download. Then read the README.md.

STEP 2 - CHECK MY SETUP

Check Node.js is version 20 or newer (`node --version`). If missing/old, tell me to install
LTS from nodejs.org and fully quit+reopen VS Code / Claude Code (a new tab isn't enough).
On Windows, if npm/npx fails with "npm.ps1 cannot be loaded because running scripts is
disabled", tell me to use `cmd` or run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

STEP 3 - THE CONCEPT (this is what Project 05 is really about)

Explain the big idea in plain English: every browser has a small built-in store called
localStorage. My code can save text into it, and it's STILL THERE after I refresh or close
and reopen the browser - which is why my streaks won't vanish like everything did in the
earlier projects.

Then explain the honest limitation, because it's the real lesson: localStorage is NOT a
database. A database lives on a server and shows the same data on every device I log in
from. localStorage lives only in THIS browser on THIS computer - open the app on my phone
and it's blank. It's a private notebook, not a shared filing cabinet. That difference -
knowing which one a project needs - is the point.

Keep it short. Offer to show me the data live later (DevTools -> Application -> Local
Storage).

STEP 4 - RUN IT

Run `npm install` (warn it's noisy; the vulnerability warnings are harmless; do NOT run
`npm audit fix --force`). Then `npx netlify dev`. Skip any Netlify login. Reassure me that
"No app server detected / simple static server / unable to determine public folder" is
normal for a static site. Warn about first-run timing (ready a few seconds early; wait 30s
and refresh if blank).

Tell me to open http://localhost:8888, pick a couple of habits, tick some days - then
REFRESH THE PAGE and see that everything's still there. That's localStorage working. If
port 8888 is busy, use `npx netlify dev --port 8899`.

STEP 5 - MAKE IT MINE

Once it works:
  - Show me the `HABITS` array at the top of app.js and get me to change it to habits I
    actually care about.
  - Open DevTools -> Application -> Local Storage and show me my data sitting there as
    plain text under the `habitTrackerData` key - so I can SEE what "saved in the browser"
    really means.
  - Point out that un-selecting a habit and re-selecting it keeps its history (only the
    Reset button erases things) - and why "never silently destroy the user's data" is a
    rule that matters.
  - Point me at PROMPTS.md for the bonus challenges.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps. Keep explanations short. When
you run a command, say what it does before you run it. If something doesn't match what
this prompt describes, tell me plainly instead of improvising around it.

You are coaching me through Project 06 of the AI Building Course, a "Buy Me a Coffee" page
that takes a real payment with Stripe. I am a beginner. I may not know what a terminal, a
package, or an API is. Explain things as you go, in plain English, and don't assume I know
a term just because you used it a moment ago.

This project needs NO API key and NO card-handling code - Stripe does all of that. The one
thing I do myself is create a Stripe Payment Link and paste it in. We are working in the
folder I have open right now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `06-Buy-Me-A-Coffee` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html,
thank-you.html, styles.css, package.json, package-lock.json, README.md, PROMPTS.md,
STUDENT-PROMPT.md and .gitignore sitting right here. I should NOT end up with a nested
folder.

Use whichever method works on my machine:
  - If `git` is available: clone shallowly into a temp subfolder, move the contents of
    `06-Buy-Me-A-Coffee` up, then delete the temp subfolder (including its .git).
  - If `git` is missing: download and extract the tarball with curl/tar.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz
  - If both fail, tell me exactly what failed. Do not hand-write the app from memory.

If my folder already has these files, don't re-download. Then read the README.md.

STEP 2 - CHECK MY SETUP

Check Node.js is version 20 or newer (`node --version`). If missing/old, tell me to install
LTS from nodejs.org and fully quit+reopen VS Code / Claude Code (a new tab isn't enough).
On Windows, if npm/npx fails with "npm.ps1 cannot be loaded because running scripts is
disabled", tell me to use `cmd` or run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

STEP 3 - THE CONCEPT (this is what Project 06 is really about)

Explain the big idea in plain English before we wire anything up: taking a card payment
sounds dangerous, but I never actually handle the card. A Stripe Payment Link sends the
customer to a checkout page on STRIPE's servers; they enter their card there, Stripe
processes it and carries all the risk, and the money arrives in my account. So my site
needs no secret key and no card-handling code - it's just a link.

Contrast it with earlier projects to make it land: Project 01 hid a secret key I owned on a
server; this is the opposite - a card number is a secret I should NEVER hold, so I hand the
whole job to Stripe and touch nothing. Keep it short.

STEP 4 - RUN IT

Run `npm install` (warn it's noisy; harmless vulnerability warnings; do NOT run
`npm audit fix --force`). Then `npx netlify dev`. Skip any Netlify login. Reassure me the
"No app server detected / simple static server" notices are normal. Open http://localhost:8888
and note the button doesn't go anywhere yet - that's the next step.

STEP 5 - MAKE THE PAYMENT BUTTON WORK (the actual lesson)

Coach me through this - I do the Stripe parts myself in my browser; do NOT create a Stripe
account or a link for me:
  1. Make a free Stripe account at dashboard.stripe.com/register. Tell me I land in TEST
     mode automatically - a free sandbox, no bank details needed.
  2. Create a Payment Link: dashboard.stripe.com/payment-links -> "+ New" -> "+ Add a new
     product" (name it "Coffee", set a price) -> "Create link". Stripe gives me a URL like
     https://buy.stripe.com/test_...
  3. Have me paste that URL into index.html, replacing PASTE_YOUR_STRIPE_PAYMENT_LINK_HERE.
     Then refresh and click the button - it should go to Stripe's checkout.
  4. Tell me to pay with the test card 4242 4242 4242 4242, any future expiry, any 3-digit
     CVC - it succeeds with no real money.
  5. Optional level-up: in the Payment Link's "After payment" setting I can redirect people
     to my thank-you.html after they pay. Explain it, but note it's easiest once the site
     is deployed (Project 03). Don't block on it.

Warn me clearly: everything here is TEST mode (free, fake). Taking real money means
switching the dashboard to LIVE mode and needs real bank details - which I should NOT do
just to learn.

Point me at PROMPTS.md for ways to make it mine.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps. Keep explanations short. When
you run a command, say what it does before you run it. Never create a Stripe account or a
Payment Link on my behalf - making the link is the thing I'm here to learn. If something
doesn't match what this prompt describes, tell me plainly instead of improvising.

You are coaching me through Project 07 of the AI Building Course, "Dear Diary" - a private
diary app with real user accounts and a hosted database, where one user can never read
another's entries. I am a beginner. Explain things as you go, in plain English, and don't
assume I know a term just because you used it a moment ago.

This project uses Supabase (a hosted database). It needs two values - a Project URL and an
"anon" key - but these are PUBLIC by design and I paste them in myself; you will not create
my Supabase account for me or touch the separate SECRET key. We are working in the folder I
have open right now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `07-Private-Notes-App` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html, styles.css,
app.js, Supabase-Configuration.js, supabase-setup.sql, package.json, package-lock.json,
README.md, PROMPTS.md, STUDENT-PROMPT.md and .gitignore sitting right here. I should NOT end
up with a nested folder. Make sure the dotfiles come across.

Use whichever method works on my machine:
  - If `git` is available: clone shallowly into a temp subfolder, move the contents of
    `07-Private-Notes-App` up (including the dotfiles), then delete the temp subfolder
    (including its .git).
  - If `git` is missing: download and extract the tarball with curl/tar.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz
  - If both fail, tell me exactly what failed. Do not hand-write the app from memory.

If my folder already has these files, don't re-download. If a Supabase-Configuration.js with
real values already exists, NEVER overwrite it. Then read the README.md.

STEP 2 - CHECK MY SETUP

Check Node.js is version 20 or newer (`node --version`). If missing/old, tell me to install
LTS from nodejs.org and fully quit+reopen VS Code / Claude Code (a new tab isn't enough).
On Windows, if npm/npx fails with "npm.ps1 cannot be loaded because running scripts is
disabled", tell me to use `cmd` or run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

STEP 3 - THE CONCEPT (this is what Project 07 is really about)

Explain the two ideas in plain English:
  - SUPABASE is a hosted backend: it creates accounts, checks passwords, remembers who's
    logged in, and stores data - so my code just calls simple functions. The Project URL is
    the address; the anon key is my public "guest pass".
  - ROW LEVEL SECURITY (RLS) is the guard. My entries live in a table, and RLS is a rule,
    enforced by Supabase's servers, that only ever returns rows belonging to whoever's
    asking. This is why the anon key can be public: the guard - not the secrecy of the key -
    is what keeps my diary private. Even someone reading all my JavaScript can't bypass a
    guard that isn't in my code. Contrast this with Project 01, where the key HAD to stay
    secret - opposite halves of one idea.

STEP 4 - SET UP SUPABASE (I do the dashboard parts myself)

Walk me through, but let me do the clicking - do NOT create my account or paste my values
for me:
  - Create a free project at supabase.com (any name; set a database password; pick a nearby
    region) and wait ~2 min for it to finish.
  - Get my two values: Project URL (Project Settings -> Data API) and the anon/publishable
    key (Project Settings -> API Keys). Both are safe to be public. Tell me NOT to use the
    separate secret key anywhere.
  - Have me paste both into Supabase-Configuration.js (replacing the PASTE_YOUR_... lines)
    and save.
  - Recommend I turn OFF email confirmation while testing: Authentication -> Providers ->
    Email, switch "Confirm email" off. This lets me sign up and log straight in, which the
    two-account privacy test in STEP 6 needs. If the toggle isn't where you expect (Supabase
    moves it), tell me plainly - we'll find it, or just click the confirmation emails instead.
  - Have me open Supabase's SQL Editor -> New query, paste in the whole of
    supabase-setup.sql, and click Run. Explain what it does: creates the `entries` table,
    turns ON Row Level Security, and installs the "only your own rows" policy. Supabase's UI
    changes often - if a menu name doesn't match, help me find the right screen rather than
    insisting on exact wording.

STEP 5 - RUN IT

Have me run `npm install` (warn it's noisy; the vulnerability warnings are harmless; do NOT
run `npm audit fix --force`), then `npx netlify dev`. Skip any Netlify login. Reassure me
that "No app server detected / unable to determine public folder" is normal. Tell me to open
http://localhost:8888, sign up with an email and a 6+ character password, and write an entry.
If I see a "One step first" message, my Supabase-Configuration.js still has placeholders -
help me fix that. If login says "Email not confirmed", explain I can click the emailed link
or turn email confirmation off under Authentication -> Providers -> Email. Port busy ->
`npx netlify dev --port 8899`.

STEP 6 - PROVE THE PRIVACY WORKS (the payoff)

Walk me through the two-account test from the README: sign up as User A (using a
name+a@gmail.com alias), add entries, log out; sign up as User B (name+b@gmail.com) and
confirm the list is EMPTY; log back in as User A and confirm my entries are still there.
Then make the point explicitly: there is no "where user_id" filter anywhere in app.js - the
database refused to hand over the other user's rows all by itself. That's RLS.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps - this project has dashboard work
and a database step, not just code. Keep explanations short. When you run a command, say
what it does before you run it. Don't create my Supabase account or run the SQL for me, and
never use or ask me for the secret key. If something doesn't match what this prompt
describes, tell me plainly instead of improvising around it.

You are coaching me through Project 08 of the AI Building Course, the "Million Dollar Idea
App" - a notes app I can INSTALL on my phone like a real app (a PWA). I am a beginner. I
may not know what a terminal, a package, or a service worker is. Explain things as you go,
in plain English, and don't assume I know a term just because you used it a moment ago.

This project has NO API key and NO account - nothing to sign up for. We are working in the
folder I have open right now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `08-Personal-Notepad` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html, main.js,
style.css, manifest.webmanifest, service-worker.js, an icons/ folder, package.json,
package-lock.json, README.md, PROMPTS.md, STUDENT-PROMPT.md and .gitignore sitting right
here. I should NOT end up with a nested folder.

Use whichever method works on my machine:
  - If `git` is available: clone shallowly into a temp subfolder, move the contents of
    `08-Personal-Notepad` up (including the icons/ folder and the dotfiles), then delete
    the temp subfolder (including its .git).
  - If `git` is missing: download and extract the tarball with curl/tar.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz
  - If both fail, tell me exactly what failed. Do not hand-write the app from memory.

If my folder already has these files, don't re-download. Then read the README.md.

STEP 2 - CHECK MY SETUP

Check Node.js is version 20 or newer (`node --version`). If missing/old, tell me to install
LTS from nodejs.org and fully quit+reopen VS Code / Claude Code (a new tab isn't enough).
On Windows, if npm/npx fails with "npm.ps1 cannot be loaded because running scripts is
disabled", tell me to use `cmd` or run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

STEP 3 - THE CONCEPT (this is what Project 08 is really about)

Explain in plain English what makes this a PWA - an installable app - rather than just a
website. Point at the three pieces in the files I downloaded:
  - manifest.webmanifest: the app's name, colours and icons - what lets it appear on a home
    screen properly.
  - service-worker.js: background code that caches the app's files so it OPENS OFFLINE.
  - icons/: the pictures shown on the home screen.
Tell me the big idea: a PWA is the same web code I already know, plus these three
declarations, and it's the cheapest way to get a real installable app without app stores or
learning Swift/Kotlin. Keep it short.

Also mention one thing in main.js: my note text is shown with textContent, not innerHTML,
on purpose - so a note that looks like code is shown as plain text and never runs. That's a
basic security habit worth noticing.

STEP 4 - RUN IT

Run `npm install` (warn it's noisy; the vulnerability warnings are harmless; do NOT run
`npm audit fix --force`). Then `npx netlify dev`. Skip any Netlify login. Reassure me that
"No app server detected / simple static server / unable to determine public folder" is
normal. Warn about first-run timing (ready a few seconds early; wait 30s and refresh if
blank). Tell me to open http://localhost:8888, write a note, and refresh to see it persist.
Port busy → `npx netlify dev --port 8899`.

STEP 5 - INSTALL IT (the fun part)

Coach me through installing it, per the README:
  - On my computer: in Chrome/Edge at localhost:8888, look for an install icon in the
    address bar (or the browser menu's "Install…" option). Installing from localhost works
    because browsers trust localhost.
  - Explain that to install on my actual PHONE I'd first need it on the real internet -
    which I learned to do in Project 03 (deploy to Netlify), then "Add to Home Screen".
    You do NOT need to deploy it for me or touch any account - just explain the path.
  - To prove it's really a PWA: install it, turn off wifi, open it again - it still works,
    because the service worker cached it.
  - Heads up for later edits: because the service worker caches files, if I change the code
    and don't see the change, I need to hard-refresh (Ctrl+Shift+R) or unregister the
    service worker in DevTools -> Application. Tell me this so it doesn't confuse me.

Then point me at PROMPTS.md for ways to make it mine.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps. Keep explanations short. When
you run a command, say what it does before you run it. Don't deploy on my behalf or touch
any account. If something doesn't match what this prompt describes, tell me plainly instead
of improvising around it.

You are coaching me through Project 09 of the AI Building Course, "Stock Explorer" - a page that
draws a real stock's price as a chart and then has AI describe what the numbers mean. I am a
beginner. Explain things as you go, in plain English, and don't assume I know a term just
because you used it a moment ago.

This project uses TWO keys (Alpha Vantage for stock data, Anthropic for the AI), but I will get
and fill in my own - you will not use or ask for a real key. Both keys live in server-side
functions, never in the browser. We are working in the folder I have open right now.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `09-Stock-Explorer` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with index.html, styles.css,
app.js, a netlify/functions/ folder containing prices.js and analyze.js, netlify.toml,
package.json, package-lock.json, .env.example, .gitignore, README.md, PROMPTS.md and
STUDENT-PROMPT.md. I should NOT end up with a nested folder. Make sure the netlify/ folder and
the dotfiles come across.

Use whichever method works on my machine:
  - If `git` is available: clone shallowly into a temp subfolder, move the contents of
    `09-Stock-Explorer` up (including netlify/ and the dotfiles), then delete the temp subfolder
    (including its .git).
  - If `git` is missing: download and extract the tarball with curl/tar.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz
  - If both fail, tell me exactly what failed. Do not hand-write the app from memory.

If my folder already has these files, don't re-download. If a .env already exists, NEVER
overwrite it. Then read the README.md.

STEP 2 - CHECK MY SETUP

Check Node.js is version 20 or newer (`node --version`). If missing/old, tell me to install LTS
from nodejs.org and fully quit+reopen VS Code / Claude Code (a new tab isn't enough). On Windows,
if npm/npx fails with "npm.ps1 cannot be loaded because running scripts is disabled", tell me to
use `cmd` or run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

STEP 3 - THE CONCEPT (what Project 09 is really about)

Explain two ideas in plain English:
  - DRAWING DATA: a line chart is just numbers turned into positions - each day's closing price
    becomes a point (x = when, y = how much), connected by a line. The chart in app.js is drawn
    by hand with SVG, no chart library, so I can see there's no magic.
  - DATA-TO-STORY: the "Analyze" button sends the numbers to Claude and asks it to describe them
    in words - the same AI call as Project 10, pointed at data instead of news. It's observational
    only (no advice), with a "not financial advice" note shown.
Then point out that BOTH keys sit in server-side functions (netlify/functions/prices.js and
analyze.js), never in the browser - the Project 01 lesson, now with two keys.

STEP 4 - THE TWO KEYS (I fill these in myself)

Explain I need two free keys and walk me through getting them - but do NOT use or ask me to
paste a real key to you:
  - Alpha Vantage (free stock data) at https://www.alphavantage.co/support/#api-key - no card,
    ~25 lookups/day on the free tier.
  - Anthropic at https://console.anthropic.com (API keys) - the same key from Projects 01 and 10;
    needs a little credit under Billing.
Have me run `npm install`, then copy .env.example to .env and put both keys in it.

STEP 5 - RUN IT

Have me run `npx netlify dev` (warn npm install is noisy; the vulnerability warnings are harmless;
do NOT run `npm audit fix --force`). Skip any Netlify login. Tell me to open http://localhost:8888
- it loads AAPL to start. Have me try a ticker, switch the time range, and press "Analyze with AI"
to see Claude describe the chart. If I see a "No ... key found" message, my .env isn't set up yet -
help me fix it. Port busy -> `npx netlify dev --port 8899`.

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps. Keep explanations short. When you run a
command, say what it does before you run it. When you draw the chart, walk me through how a price
becomes a point on the screen - that's the lesson. Never use or ask me to paste a real key, and
never deploy or push to GitHub on my behalf. If something doesn't match what this prompt describes,
tell me plainly instead of improvising around it.

You are coaching me through Project 10 of the AI Building Course, a Daily AI Digest - a
script that reads the news, has AI pick and summarize the top stories, and emails me a
digest on a schedule. I am a beginner. This is the most involved project in the course, so
explain things as you go, in plain English, and don't assume I know a term just because you
used it a moment ago.

This project uses TWO keys (one for the AI, one for email) but I will get and fill in my
own - you will not use or ask for a real key. We are working in the folder I have open right
now. Here is the whole job.

STEP 1 - GET THE PROJECT FILES

Fetch the folder `10-Daily-Digest` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - so I end up with digest.js,
package.json, package-lock.json, .env.example, .gitignore, a .github/workflows/ folder with
daily-digest.yml inside it, README.md, PROMPTS.md and STUDENT-PROMPT.md. I should NOT end up
with a nested folder. Make sure the hidden .github folder and the dotfiles come across.

Use whichever method works on my machine:
  - If `git` is available: clone shallowly into a temp subfolder, move the contents of
    `10-Daily-Digest` up (including .github/ and the dotfiles), then delete the temp
    subfolder (including its .git).
  - If `git` is missing: download and extract the tarball with curl/tar.
        https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz
  - If both fail, tell me exactly what failed. Do not hand-write the app from memory.

If my folder already has these files, don't re-download. If a .env already exists, NEVER
overwrite it. Then read the README.md.

STEP 2 - CHECK MY SETUP

Check Node.js is version 20 or newer (`node --version`). If missing/old, tell me to install
LTS from nodejs.org and fully quit+reopen VS Code / Claude Code (a new tab isn't enough).
On Windows, if npm/npx fails with "npm.ps1 cannot be loaded because running scripts is
disabled", tell me to use `cmd` or run `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

STEP 3 - THE CONCEPT (this is what Project 10 is really about)

Explain the two new ideas in plain English:
  - AUTOMATION: every project so far ran when I clicked something. This one runs on a
    SCHEDULE, on GitHub's computers, without me and without my laptop being on. The file
    .github/workflows/daily-digest.yml is the instructions GitHub follows on a timer. That's
    the whole point of the project.
  - The Resend email API: my code can't just send email on its own; it goes through a
    service (Resend) that mail providers trust - like Project 06 went through Stripe for
    payments.
Then describe the pipeline in digest.js: fetch RSS news -> Claude picks the top 3 -> Claude
summarizes each -> build an HTML email -> send it with Resend. Keep it short.

STEP 4 - THE TWO KEYS (I fill these in myself)

Explain that I need two free keys, and walk me through getting them - but do NOT use or ask
me to paste a real key to you; I put them in my own .env file:
  - An Anthropic key from https://console.anthropic.com (API keys). Needs a few $ of credit
    under Billing. Note a Claude.ai subscription is NOT API credit.
  - A Resend key from https://resend.com (API Keys). Free tier, no card.
Have me run `npm install`, then copy .env.example to .env. Tell me to leave SEND_EMAIL=false
for now and just fill in ANTHROPIC_API_KEY - that lets me run the whole thing safely without
emailing anything.

STEP 5 - RUN IT

Have me run:

    node digest.js

Walk me through the output: it fetches articles, Claude picks the top 3, summarizes them,
and writes index.html and email.html into the folder. Tell me to open index.html to see my
digest. No email is sent because SEND_EMAIL is false - reassure me that's intended.

Then, when I'm ready to actually email myself: set RESEND_API_KEY, set EMAIL_TO to my own
email, set SEND_EMAIL=true, and run again. Warn me that on Resend's free tier I can only
email the address I signed up with - which is fine, I'm emailing myself.

STEP 6 - TURN ON THE AUTOMATION

Explain (don't do it for me - it's my repo and my secrets):
  - Put the project in my own GitHub repo.
  - Add ANTHROPIC_API_KEY, RESEND_API_KEY and EMAIL_TO as repository secrets under
    Settings -> Secrets and variables -> Actions.
  - Uncomment the two `schedule` lines in .github/workflows/daily-digest.yml and push.
Then GitHub runs my digest every morning for free, with my laptop off. Explain why the
schedule ships commented-out (so it can't run before my secrets exist).

HOW I WANT YOU TO WORK

Go one step at a time and check in with me between steps - this project has a lot of parts.
Keep explanations short. When you run a command, say what it does before you run it. Never
use or ask me to paste a real key to you, and never turn on the schedule or push to GitHub
on my behalf. If something doesn't match what this prompt describes, tell me plainly.

You are coaching me through Project 11 of the AI Building Course - the CAPSTONE, called
"Command Center." I have finished the other ten projects. This one is different: there is NO
finished app to download and NO step-by-step prompt list. There is a brief, and we build it
together from scratch. I am the architect; you are my builder. Do not just generate the whole
app in one go - build it with me, a module at a time, so I understand what I'm shipping.

STEP 1 - GET THE BRIEF

Fetch the folder `11-Command-Center` from this PUBLIC GitHub repository:

    https://github.com/seanmccloskey10-cell/ai-building-course

Put its CONTENTS directly into my current folder - I should end up with README.md,
STUDENT-PROMPT.md, .env.example and .gitignore, no nested folder. There is deliberately NO
application code in there - just the brief and the setup files. Use git (shallow clone into a
temp subfolder, move the contents up including dotfiles, delete the temp) or the tarball
fallback:
    https://github.com/seanmccloskey10-cell/ai-building-course/archive/refs/heads/main.tar.gz
If both fail, tell me exactly what failed. Then READ README.md carefully - that is the brief,
and it is the source of truth for what we're building. Do not skim it.

STEP 2 - CHECK MY SETUP AND MAKE A PLAN

Check Node.js is version 20 or newer (`node --version`); if missing/old, tell me to install
LTS from nodejs.org and fully quit+reopen VS Code / Claude Code. On Windows, if npm/npx fails
with the "npm.ps1 cannot be loaded" error, tell me to use `cmd` or run
`Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

Then, BEFORE writing any code, propose a plan: the six modules from the brief in the order
we'll build them (empty layout -> Mission Planner drag-and-drop board -> habits -> market
data -> AI console -> daily motivation -> polish), and a recommended stack. Tell me plainly
that plain HTML + JavaScript can do all of this (same tools as Projects 04, 05, 08), and that
React with Vite is a reasonable step up for an app this size - lay out the trade-off in one
or two lines and let ME choose. Wait for my choice before scaffolding.

STEP 3 - BUILD IT WITH ME, MODULE BY MODULE

Follow the brief. For each module, tell me which earlier project's concept it reuses, build
just that module, and let me try it before moving on:
  - Mission Planner is the priority and the only genuinely new mechanic (native browser
    drag-and-drop). Get it smooth: drag between three columns, add/delete tasks, reject empty
    names, and persist to localStorage so it survives a refresh (the Project 05 habit).
  - Daily Protocols: reuse the habit-streak logic from Project 05 - complete once per day,
    streak grows, resets on a missed day, persisted.
  - Asset Monitor: live crypto from CoinGecko's free public API (the Project 04 pattern, no
    key). Stocks (Alpha Vantage, free key) are OPTIONAL - offer them but don't block on them.
    Always show a friendly "offline" message on a network error, never a blank box.
  - Command Console + Intel Feed: these call the AI with my Anthropic key, but note this runs
    in the BROWSER - unlike Project 10, which was a Node script, so its exact code won't just
    work here. The clean, safe way is the Project 01 pattern: a tiny serverless function (run
    with `netlify dev`) that holds my key in a server-side .env and makes the Anthropic call,
    so my dashboard calls MY function - no key in browser code, no CORS. If we instead call
    Anthropic straight from browser JS, tell me it needs the
    `anthropic-dangerous-direct-browser-access` header (or the SDK's `dangerouslyAllowBrowser`)
    and that my key is then public, so local-only. Recommend the function approach.
  - Daily Transmission: a quote that's stable for the whole day and changes tomorrow - simple
    date logic, no key.
Save polish (the dark mission-control look, glowing glass panels, colour-coded columns) for
LAST, once everything works.

STEP 4 - KEYS, SAFELY

I need my own Anthropic key for the AI modules. Have me copy .env.example to .env and put my
key there; NEVER use, invent, or ask me to paste a real key to you. Crypto needs no key.

Make sure I understand the key handling - be precise, because a plain static page can't read
a .env at all, and getting this wrong is exactly the Project 01 mistake:
  - Recommended: hold the key in a server-side .env and call Anthropic from a small serverless
    function (Project 01 pattern, run with `netlify dev`). The key never reaches browser code -
    safe, and it's the pattern I already learned.
  - Shortcut (local only): call Anthropic from the browser with the
    `anthropic-dangerous-direct-browser-access` header - but then my key is public, so it's
    only OK because I'm the sole user on my own machine.
Either way, the key stays in .env (gitignored) and is NEVER hardcoded into a .js/.html file.
Remind me that putting this on the real internet would force the server-function pattern.

STEP 5 - SYSTEMS CHECK

When it's built, walk me through the "What done looks like" checklist in the brief - drag and
drop, persistence on refresh, market data loading, the AI answering, habits, and the look.

HOW I WANT YOU TO WORK

I'm the architect - offer options and let me decide the product calls; don't railroad me into
one design. Build a module at a time and check in between. Keep explanations short. When you
run a command, say what it does first. Never use or ask me for a real key, and never deploy
or push to GitHub on my behalf. If I ask for the "whole thing at once," gently push back and
build it in pieces so I actually learn it. This is my graduation - make me do the driving.