Course 1 · In production
The Hidden Curriculum
What nobody taught you about building with AI: terminals, files, git, keys, hosting and the rest, drawn as a map you can keep in your head.
These aren't step-by-step tutorials. Each lesson tells you what a thing is, where it lives, what it connects to, and what will surprise you when you meet it, so the first time you do it for real is not the first time you've heard of it.
214lessons
22modules
6districts
~10minutes a lesson
12 of 214 lessons available · 115 min total · more coming soon
Latest lesson · 01.06Programs, processes & services 10:45 How it works A framework, not a checklist Lesson 00.01 covers this too; open it if you'd rather read.
The confusing part of building with AI is rarely the code. It's the dozen things around it that everyone assumes you already know. This course hands them to you in an order that makes sense.
A map, not a manual
Every idea gets a shelf
Six districts, walked in order: from the files on your own computer, out to the network, trust and shipping. Each lesson pins itself to the map, so new ideas land somewhere instead of piling up.
Five questions, every lesson
The same shape each time
- What is it?
- Where does it live?
- What is it like?
- What does it connect to?
- What will surprise you?
Short, with a transcript
A few minutes each
Every lesson is animated and narrated, with captions, chapters, a transcript you can click to jump around, and an MP4 to keep.
The map
Start, six districts, finish
This is the whole course, in the order it's released. Start at Orientation, walk the six districts from your own computer out to the people using what you ship, and finish by building one real project. Open a module to see its lessons.
The lanterns
AI isn't a district. It hangs over all six, like lanterns over the streets. The 39 lessons about AI sit inside the district they belong to and carry a lantern : coding agents with development environments, agents on git with Git. Every other lesson also says where AI shows up, when it does.
-
Start here
Orientation
What this course is, and the lantern you carry
- 00.01 The hidden curriculumBuilding with AI runs on everyday tools that school rarely teaches, so the gap is in the syllabus, not in you. This lesson shows why, and lays out the map every later lesson is shelved on.
- 00.02 The map of everythingEverything you build with AI sits on one road with five stops (your computer, the network, the internet, services, AI), so when something breaks, ask which stop first. This lesson draws that road and gives every later lesson its place on it.
- 00.03 How old is all this?The ideas under your tools are decades old, but old does not mean frozen: versions change every year, security changes fastest (text codes to authenticator apps to passkeys, broken hashes, retired TLS) and AI on top changes fastest of all, so learn the ideas once, check the version, and assume old login advice is out of date.
- 00.04 Model vs app vs agent(about AI)The model is the engine (a lab's file of numbers: text in, text out, no memory), the app is the car built around it (chat window, saved chats, hidden instructions, the bill), and an agent is that car allowed to drive, with tools, a loop and you deciding what it may do.
- 00.05 How AI models work today(about AI)Underneath it all is still a model that only knows what is on its desk right now; nearly everything new in the last five years (multimodal hand-offs, diffusion, memory and RAG, instruction files, caching, modes, plugins, plans and always-on agents) is about what gets put on that desk, what it hands off to other models, and where the desk sits.
- 00.06 Trust what you can verify(about AI)You can only trust AI on what can actually be checked: agents now fix their own crashes, so your job is judging what they cannot see (security holes in code that works, team norms, dependencies, "ready to deploy"), and past that line you either learn to check it or bring in someone who can.
-
District 1 of 6
The Machine
What's on your computer
01 Your Computer, Under the Hood 4 about AI 6 of 13 available
- 01.01 Files are just bytesEvery file is just a row of numbers called bytes, and the extension is a label on its name that picks which program opens it, not what is inside; this lesson draws that picture so nothing an agent does with your files surprises you.
- 01.02 File extensions & associationsThe extension is a label in a file's name and your computer keeps a ledger matching each label to a program, so renaming changes the label but never the bytes, while Open with set to Always and default apps edit the ledger; this lesson draws that picture as of October 2026, with AI tools now making the files.
- 01.03 Folders, paths & the working directoryA path is an address, and a relative path only makes sense from the working directory of the program that reads it.
- 01.04 Hidden files & dotfilesAlmost every project and app keeps its settings, history, secrets and now its AI instructions in files your computer hides or tucks out of the way, and hidden only means out of sight, never locked.
- 01.05 Environment variables & PATHEvery program starts with a copy of its parent's settings, its environment, and PATH in it is an ordered list of folders where the first match wins, so which program runs and which keys it can see depend on who started it and when.
- 01.06 Programs, processes & servicesA program is a file of instructions, a process is one running copy of it with its own number, memory and copied settings, and a service is a process the operating system keeps alive in the background, so most of what your AI tools run is processes you never see a window for.
- 01.07 Users, admin & permissionsAdmin vs standard, UAC prompts, "Run as administrator", file permissions
- 01.08 Windows vs macOS vs LinuxSame ideas, different names: line endings, path slashes, case-sensitivity, package managers
- 01.09 CPU, RAM, disk, GPU & VRAMWhat each does and why AI cares about the GPU and its VRAM
- 01.10 Running AI models on your own computer(about AI)Ollama, LM Studio, ComfyUI; VRAM limits; quantization
- 01.11 The copilot zoo(about AI)OS (Windows Copilot, Apple Intelligence), browser, email, IDE (GitHub Copilot), vendor (NVIDIA app/G-Assist), Office — what each can see
- 01.12 What AI is already on your PC?(about AI)How to inventory assistants, background AI services and their data access
- 01.13 How image, video and sound generators work(about AI)Diffusion and flow models: noise to picture in steps; why image, video, music and voice generators work this way; diffusion for text exists but is rare
02 The Command Line 8 lessons Not released yet
- 02.01 Terminal vs console vs shell vs CLITerminal = the window; shell = the interpreter inside it; CLI = any program you drive by typing; console = the old name
- 02.02 The shells: cmd, PowerShell, bash, zsh, Git Bash, WSLWhich one you're in, why syntax differs, when to use each
- 02.03 Moving aroundcd, ls/dir, pwd, tab-completion, up-arrow history, opening a terminal in a folder
- 02.04 Running programs: commands, arguments, flagspython app.py --verbose: program, argument, flag; --help
- 02.05 Input, output, pipes & redirectsstdout, stderr, |, >, exit codes — how programs talk to each other
- 02.06 Script files: .bat, .cmd, .ps1, .shSaving commands to a file; execution policy; shebangs; double-click vs run
- 02.07 OS package managerswinget, Chocolatey, Scoop, Homebrew, apt — installing software by typing
- 02.08 Reading errors without panicStack traces, "command not found", permission denied, and what each means
03 Development Environments 3 about AI 10 lessons Not released yet
- 03.01 Text editor vs IDENotepad → VS Code → full IDEs; what an IDE adds
- 03.02 VS Code tourExplorer, integrated terminal, extensions, command palette, settings
- 03.03 The IDE familyCursor/Windsurf, JetBrains (PyCharm etc.), Visual Studio, Xcode, Android Studio, Unity/Godot editors — when to use which
- 03.04 Linters, formatters & type checkersTools that catch mistakes before you run
- 03.05 The debuggerBreakpoints and stepping instead of print() everywhere
- 03.06 NotebooksJupyter, Colab — when notebooks beat scripts and when they don't
- 03.07 WSL, dev containers & cloud dev environmentsLinux on Windows, Codespaces, why teams standardize environments
- 03.08 Coding agents in your editor and terminal(about AI)Claude Code, Codex, Copilot agent, Cursor — how they read, edit, run
- 03.09 Instruction files: prompts as code(about AI)Instructions files (CLAUDE.md etc.), versioning prompts
- 03.10 Context engineering: managing the window(about AI)Why models get worse as the window fills (context rot); compaction, clearing tool results, sub-agents, loading tools and skills on demand
-
District 2 of 6
The Code
What programs are made of
04 Programming Languages 7 lessons Not released yet
- 04.01 What a programming language actually isHuman-readable instructions → something the machine runs
- 04.02 Compiled vs interpreted vs bytecodeC/Rust/Go vs Python/JS vs Java/C# — what "runtime" means
- 04.03 The language tourPython, JavaScript/TypeScript, HTML/CSS, SQL, Bash/PowerShell, C/C++, C#, Java/Kotlin, Swift, Go, Rust, Lua/GDScript — what each is for
- 04.04 Choosing a languageBy target: web, AI/data, scripting, mobile, games, systems, automation
- 04.05 Libraries, frameworks, SDKs & runtimesLibrary = you call it; framework = it calls you; SDK = a vendor's toolkit
- 04.06 Data formatsJSON, YAML, TOML, CSV, XML, Markdown — config and data files you'll meet daily
- 04.07 Text encoding: Unicode, UTF-8 and garbled charactersText is bytes plus an agreement: code points, UTF-8 vs UTF-16, why é (mojibake) appears and how to read it (deferred from 01.01)
05 Python & JavaScript Ecosystems (Packages) 9 lessons Not released yet
- 05.01 Why there are so many Pythons on your computerInstaller vs Store vs uv; multiple versions; the py launcher; which one "python" means
- 05.02 What "running a file" really meansAn interpreter reads your text file; the working directory decides what it can find; why imports fail from the wrong folder
- 05.03 Virtual environments (.venv)Per-project package boxes; activate/deactivate; why global installs break things
- 05.04 pip, requirements.txt, pyproject.toml, uvDeclaring and reproducing dependencies
- 05.05 Node.js, npm & npxpackage.json, node_modules, scripts (npm run dev), npx one-offs
- 05.06 Lockfiles & semantic versioning1.4.2 means what; why lockfiles exist
- 05.07 Who can publish packages?Anyone — PyPI/npm accounts, publishing flow, trust signals
- 05.08 Supply-chain riskTyposquatting, malicious packages, install scripts, how to vet a package
- 05.09 Version managers & shimsmise, pyenv, nvm, asdf: tools that put a stand-in (shim) first on PATH and pick the version per project; why which python can name a shim, not the real program (deferred from 01.05)
06 Data & Databases 2 about AI 7 lessons Not released yet
- 06.01 Why apps need databasesBeyond files
- 06.02 SQL & relational databasesSQLite, Postgres, tables, queries
- 06.03 NoSQL & key-value storesDocuments, KV, when they fit
- 06.04 Hosted backendsSupabase, Firebase, Neon, Cloudflare D1
- 06.05 Migrations & backupsChanging a database without losing data
- 06.06 Vector databases & embeddings(about AI)How AI "searches by meaning" (RAG)
- 06.07 How AI apps remember(about AI)The model keeps nothing: memory is text put back in the window. Re-sent conversation, self-kept memory, chat search, memory files and connectors (Notion, Drive) via tool calls
07 ConcurrencyDoing Many Things at Once 1 about AI 7 lessons Not released yet
- 07.01 Processes vs threadsSeparate houses vs roommates
- 07.02 The event loopOne worker juggling many waiting tasks (JavaScript, Python asyncio)
- 07.03 async / awaitWriting code that waits without freezing
- 07.04 Worker threads & worker poolsHanding heavy work to helpers
- 07.05 Job queues & the worker loop"Take a job, do it, report, repeat" — how render queues and AI pipelines work
- 07.06 Race conditions & locksWhy two workers touching one thing breaks it
- 07.07 Multi-agent orchestration(about AI)Fan-out, review, verify; cost and when it's worth it
-
-
District 3 of 6
The History
How work is saved & shared
08 Git, GitHub & Agents on Git 2 about AI 12 lessons Not released yet
- 08.01 What version control isSave points for code with a full history
- 08.02 Git basicsrepo, stage, commit, log, diff
- 08.03 Branches & mergingParallel timelines; merge conflicts demystified
- 08.04 Git vs GitHubGit = the tool on your PC; GitHub/GitLab/Bitbucket = hosting + collaboration
- 08.05 Remotes: clone, push, pull, forkSyncing your copy with the server copy
- 08.06 Pull requests, issues & code reviewHow teams (and agents) propose changes
- 08.07 .gitignore & never committing secretsWhat stays out of the repo and why
- 08.08 GistsTiny single-file repos for sharing snippets
- 08.09 GitHub Actions (CI/CD)Robots that test/build/deploy on every push
- 08.10 Releases, tags & GitHub PagesShipping versions and free static hosting
- 08.11 How AI coding agents use git(about AI)Agents on branches/worktrees, opening PRs, why git makes agent work safe to undo
- 08.12 Contributing with AI: team norms and AI policies(about AI)Mixed human/AI teams: AI code drifting from conventions and the agreed libraries, open-source AI disclosure policies, reviewing AI-written pull requests
-
-
District 4 of 6
The Network
How computers talk
09 Networking & the Internet 9 lessons Not released yet
- 09.01 LAN, WAN & the internetYour home network vs everyone else's; router, switch, Wi-Fi
- 09.02 IP addresses & portsAddress = building, port = apartment; private vs public IPs
- 09.03 localhost127.0.0.1 — your computer talking to itself; localhost:3000 explained
- 09.04 Clients & serversWho asks, who answers; any computer can be a server
- 09.05 DNS & domainsNames → numbers; registrars, records (A, CNAME, TXT, MX)
- 09.06 HTTP & HTTPSRequests, responses, methods, status codes, headers
- 09.07 TLS certificatesThe padlock; Let's Encrypt; why HTTPS is free now
- 09.08 Firewalls, NAT, port forwarding & VPNsWhy your PC isn't reachable from the internet (and how to change that safely)
- 09.09 CDNs, latency & bandwidthWhy sites are copied worldwide
10 APIs, Webhooks & MCP 10 about AI 16 lessons Not released yet
- 10.01 What an API isA menu of things a program lets other programs do
- 10.02 Web APIs & RESTEndpoints, JSON bodies, GET/POST/PUT/DELETE
- 10.03 Anatomy of one API callURL, method, headers, key, JSON body, status code: one request taken apart
- 10.04 SDKs, rate limits, pagination & errorsThe practical realities of APIs
- 10.05 Webhooks"Don't call us, we'll call you" — reverse APIs; polling vs push
- 10.06 WebSockets & streaming(about AI)Live two-way connections; why AI replies stream token by token
- 10.07 GraphQL & RPC (brief)Other API styles you'll bump into
- 10.08 MCP — Model Context Protocol(about AI)A standard plug that lets AI apps use tools; client, server, tools, resources
- 10.09 MCP transports & installing servers(about AI)stdio (local program) vs HTTP (remote); config files; auth for remote MCP
- 10.10 Tools, skills & MCP in practice(about AI)Giving an agent abilities
- 10.11 Subscriptions vs API billing(about AI)Chat plans vs pay-per-token keys
- 10.12 Plugin and skill marketplaces(about AI)Skills vs connectors vs plugins; directories, the Claude Marketplace, git-repo plugin marketplaces; every add-on is code you trust (malicious skills in the wild)
- 10.13 Prompt caching and the token meters(about AI)Input, cache write, cache read, output; the prefix rule and what breaks a cache; time to live (5 min / 1 h); why long chats cost more each turn
- 10.14 Multimodal APIs(about AI)Sending images, audio, video and PDFs to a model; models that generate media natively vs apps that hand off to a generator model
- 10.15 Voice AI(about AI)Voice modes: speech-to-text, model, text-to-speech pipelines vs native speech-to-speech; turn-taking and interruptions
- 10.16 What "Opus made this" leaves out(about AI)~20 min, case study (Aaron asked for it out of sequence, 2026-10-03/04). Bare Opus 5.5 vs Opus connected to engines, generators and pipelines, from controlled experiments run for this lesson: what the model really did, what references, generators, songs and people supplied, its narrow default taste, that it never hears or plays its own work, and the bill (Seedance 2.5, keep ratios, the 10,000-character "one prompt"). Uses real media exhibits (first lesson with video clips and played audio)
11 Websites & Hosting 9 lessons Not released yet
- 11.01 HTML, CSS, JavaScriptStructure, style, behavior
- 11.02 Static vs dynamic sitesPre-made pages vs pages built per request
- 11.03 SSG, SSR, SPA & islandsThe rendering acronyms explained
- 11.04 AstroContent-first static sites with islands of interactivity
- 11.05 React, Next.js & friendsWhen you need a heavier framework
- 11.06 Build steps & dev serversnpm run dev vs npm run build, the dist folder
- 11.07 How a domain name finds your siteRegistrar → DNS → host: who owns what in the chain
- 11.08 Where to hostGitHub Pages, Cloudflare Pages, Vercel, Netlify, VPS — tradeoffs and costs
- 11.09 Deploying from gitPush → auto-deploy; preview deployments
12 Cloudflare & the Edge 1 about AI 5 lessons Not released yet
- 12.01 What Cloudflare isDNS, CDN, proxy, DDoS shield in front of your site
- 12.02 Pages & WorkersHosting sites and running code at the edge
- 12.03 Storage: KV, D1, R2, Durable ObjectsWhere edge apps keep data
- 12.04 Workers AI & the Agents SDK(about AI)Running models and stateful agents on Cloudflare
- 12.05 Tunnels & Zero TrustSafely exposing localhost; protecting private apps
13 Containers, Servers & the Cloud 7 lessons Not released yet
- 13.01 "Works on my machine"The problem containers solve
- 13.02 Docker: images, containers, DockerfileRecipe → packaged box → running box
- 13.03 Volumes, ports & docker composeData and multiple services
- 13.04 When to use Docker (and when not)Servers and reproducibility yes; simple desktop scripts usually no
- 13.05 VMs vs containers vs serverlessThree ways to rent compute
- 13.06 The big cloudsAWS, Azure, GCP — and the simpler PaaS options
- 13.07 Environments: dev, staging, prodWhy you don't test on live users
-
-
District 5 of 6
Trust
Who may do what
14 Identity, Authentication & Keys (Developer Side) 1 about AI 13 lessons Not released yet
- 14.01 Authentication vs authorizationWho are you vs what may you do
- 14.02 Sessions & cookiesHow a website remembers you're logged in
- 14.03 API keys, app keys, secret vs publishable keysShared secrets; which keys may appear in a browser and which never may
- 14.04 Tokens & JWTsAccess tokens, refresh tokens, expiry, bearer headers
- 14.05 Public/private key cryptographyLock anyone can close, only you can open; signing vs encrypting
- 14.06 SSH keysPasswordless login to servers and GitHub
- 14.07 OAuth 2.0: the big ideaLetting an app act for you without giving it your password
- 14.08 OAuth flowsAuthorization Code + PKCE, Client Credentials, Device Code, refresh — which to use when
- 14.09 OpenID Connect, SSO & "Sign in with Google"OAuth + identity
- 14.10 Scopes, consent & revoking accessLeast privilege for apps
- 14.11 Service accounts & machine identitiesLogins for robots
- 14.12 Giving agents keys safely(about AI)Scoped tokens, sandboxes, permission prompts, human-in-the-loop
- 14.13 Signed webhooks (HMAC)Proving a webhook really came from Stripe/GitHub
15 Personal Security & Secrets 4 about AI 17 lessons Not released yet
- 15.01 Passwords & password managersBitwarden, 1Password: vaults, master password, autofill
- 15.02 Two-factor authenticationSMS vs authenticator (TOTP) vs push vs hardware keys
- 15.03 PasskeysPublic-key login that can't be phished
- 15.04 Recovery codes & recovery keysThe backup door — where to keep them
- 15.05 Hashing vs encryption vs encodingOne-way, two-way, and not-security-at-all (base64)
- 15.06 Encryption at rest & in transitBitLocker/FileVault, HTTPS, end-to-end
- 15.07 Keeping app secrets out of plain text.env + .gitignore → OS credential store → op run/Bitwarden Secrets Manager → cloud secret stores
- 15.08 Environment variables: user vs systemWhere they live, who can read them, what's fine to put there (paths, flags) and what isn't (long-lived secrets)
- 15.09 Windows Credential Manager & DPAPIThe OS vault; encryption tied to a Windows account, so only that account can read it (Keychain / libsecret on Mac & Linux)
- 15.10 The bootstrap secret problemEvery automation needs one first secret; where that one secret can safely live
- 15.11 When a key leaksRotate, revoke, scan history; secret scanning
- 15.12 Least privilege & threat modeling for solo devsWhat could go wrong, and cheap defenses
- 15.13 AI privacy & data use(about AI)What gets sent, trained on, and retained
- 15.14 AI at work: enterprise plans and admin controls(about AI)Individual vs Team/Enterprise: SSO, admin allow-lists for connectors, plugins and skills, audit logs, retention, managed instruction files, training defaults
- 15.15 Prompt injection and attacks on agents(about AI)Text in a page, file or email can steer an agent that reads it; why tool access turns that into real damage, and the defenses so far
- 15.16 AI that checks code: review and security agents(about AI)What 2026 review and security agents (scanners, /security-review, autofix) catch, what they miss, and why a human still approves
- 15.17 Dangerous filesDouble extensions (invoice.pdf.exe), Mark of the Web, risky attachment types: a file's name can lie about what it does (deferred from 01.01)
16 Running Things Without You 4 about AI 13 lessons Not released yet
- 16.01 Background processes & services/daemonsPrograms with no window
- 16.02 SchedulingTask Scheduler, cron, scheduled cloud jobs
- 16.03 Running without being logged inServices, "run whether user is logged on or not", SYSTEM account
- 16.04 The implicationsStored credentials, security, persistence, what malware does the same way
- 16.05 Headless machines & serversComputers with no screen; remote access (SSH, RDP)
- 16.06 Logs & monitoringHow you find out what happened while you were away
- 16.07 When you leave, does it break?The "bus factor": automations tied to personal accounts; moving them to company-owned identities
- 16.08 Windows service accounts & scheduled tasksA login for a robot on one machine, and the scheduled tasks that use it
- 16.09 Robot identities in the cloudEntra ID app registrations and service principals: how a Microsoft 365 automation runs as an app instead of a person
- 16.10 Workflow automation platforms(about AI)n8n, Zapier, Make — when no-code wins
- 16.11 Scheduled & background agents(about AI)Agents that run daily without you
- 16.12 Evals & cost tracking(about AI)Knowing whether your automation actually works and what it costs
- 16.13 Always-on personal agents(about AI)OpenClaw, Hermes Agent, Meta Muse, OpenAI dots: self-hosted vs hosted assistants that act for you around the clock, and their security record
-
-
District 6 of 6
Shipping
Getting it to people
17 What "an Application" Is 1 about AI 11 lessons Not released yet
- 17.01 Anatomy of an appFrontend, backend, database, storage, auth
- 17.02 Kinds of appsCLI, desktop, web, mobile, game, browser extension, bot, agent
- 17.03 How executables workDouble-click → OS loads machine code; .exe, .app, ELF
- 17.04 Turning scripts into appsPyInstaller, Electron, Tauri, bundlers
- 17.05 Code signing & "Windows protected your PC"Certificates, SmartScreen, Gatekeeper, notarization
- 17.06 InstallersWhat they actually do: copy files, registry, shortcuts, PATH; MSI, MSIX, Inno Setup, NSIS
- 17.07 UpdatersChecking a server for new versions, auto-update frameworks
- 17.08 UninstallersUndoing the installer; leftover AppData
- 17.09 Desktop app storesMicrosoft Store, Mac App Store, Steam, itch.io: why distribute through a store at all (phone stores are 18.06–18.09)
- 17.10 AI design and app builders(about AI)Claude Design, Docs and Slides, and other AI tools that build layouts, pages and apps; what they make (code, not pictures) and where the result lives
- 17.11 Ready to ship? What to check before real usersWho can see what, secrets, costs, rollback and monitoring: the checks an agent cannot vouch for when you ask "is it ready to deploy?"
18 Other PlatformsPhones, App Stores & Physical Devices 1 about AI 17 lessons Not released yet
- 18.01 Why cross-platform is hardDifferent OSes, CPUs (x64 vs ARM), screen sizes: one program, many machines
- 18.02 Compatibility basicsMinimum vs target OS version, API levels, backward vs forward compatibility, deprecations, CPU architectures, screen sizes and densities, "check for the feature, not the version"
- 18.03 How a phone app is differentSandboxes, permission prompts, the app lifecycle (the OS can pause or kill you), push notifications, battery and offline
- 18.04 Native, cross-platform or webSwift/Kotlin vs Flutter, React Native, .NET MAUI vs Electron/Tauri vs Unity/Godot vs installable web apps (PWAs): what each trades away
- 18.05 The mobile toolchainsXcode (why iOS apps need a Mac) and Android Studio; SDKs, simulators vs emulators, running on your own phone
- 18.06 The app storesApp Store, Google Play, Microsoft Store, Mac App Store, Steam, Amazon and Galaxy stores, EU alternative marketplaces, sideloading; what each one is for and the 15–30% cut
- 18.07 Getting your app into a storeDeveloper accounts and fees, identity checks, review guidelines and rejections, privacy labels and data-safety forms, beta testing (TestFlight, Play testing tracks)
- 18.08 Signing, IDs & releasing updatesBundle/package IDs, certificates, provisioning profiles, keystores, version numbers vs build numbers, staged rollouts; why losing a signing key is a disaster
- 18.09 Selling inside appsIn-app purchases and subscriptions, store billing rules, why outside payment links were restricted and how that is changing
- 18.10 VMs, emulators & cloud devicesTesting without owning the hardware
- 18.11 CI build matricesGitHub Actions building Mac/Linux/Windows, iOS and Android for you
- 18.12 How physical devices workMicrocontrollers vs single-board computers (Arduino, ESP32 vs Raspberry Pi), firmware, sensors and actuators, pins
- 18.13 Prototyping electronicsDev boards, breadboards, power and voltage levels, the parts that let the magic smoke out
- 18.14 Firmware & talking to devicesFlashing, serial over USB, Bluetooth LE, Wi-Fi, MQTT; the companion app on your phone
- 18.15 From breadboard to productCircuit boards (KiCad, ordering PCBs), enclosures, CAD and 3D printing, small-batch manufacturing
- 18.16 Certification & selling hardwareFCC/CE marks, pre-certified radio modules, safety, crowdfunding and hardware stores
- 18.17 AI on devices(about AI)On-device and edge AI (phone NPUs, tiny models on microcontrollers), and coding agents that write firmware
19 Payments, Users & Selling Software 7 lessons Not released yet
- 19.01 Adding login to your appAuth providers: Clerk, Auth0, Supabase Auth, Firebase Auth — don't roll your own
- 19.02 How online payments workCard networks, processors, never touching card numbers
- 19.03 StripeCheckout, products/prices, subscriptions, test mode
- 19.04 Merchant of recordLemon Squeezy, Paddle, Gumroad — they handle sales tax/VAT
- 19.05 Fulfillment via webhooksPayment succeeded → unlock access
- 19.06 License keys for desktop softwareIssuing, validating, offline activation
- 19.07 Legal pagesTerms of service, privacy policy, refunds, GDPR/CCPA basics
20 Licenses & Legal 1 about AI 7 lessons Not released yet
- 20.01 Copyright is the defaultNo license = all rights reserved
- 20.02 Permissive licensesMIT, BSD, Apache 2.0 — do almost anything, keep the notice
- 20.03 Copyleft licensesGPL, LGPL, AGPL — share-alike obligations
- 20.04 Creative Commons & content licensesFor art, docs, media
- 20.05 Proprietary, EULAs & dual licensingHow closed software is licensed
- 20.06 AI model licenses(about AI)Open weights vs open source, non-commercial licenses, output rights
- 20.07 API terms of serviceWhat you agree to when you use someone's API
-
-
Finish
Capstone
One small real project, from idea to running, using every district
- 21.01 Idea → planScoping a small real product
- 21.02 Build with an agent(about AI)Repo, venv/npm, git, secrets done right
- 21.03 Ship itDomain, hosting, auth, payments
- 21.04 Run itLogs, updates, backups, support
-
Who's making this
Aaron Orelup
I have a degree in Information Systems and I still learned most of this by breaking things: a Python script saved as .txt, a terminal open in the wrong folder, work automations tied to my own accounts. Once I was building real tools with AI, I kept meeting words nobody had taught me. This is the map I wish someone had handed me.
Questions
What people ask about the course
Do I need to know how to code?
No. The lessons explain what things are and how they fit together. If you build with AI, or want to, that is the only prerequisite.
Is this a tutorial series?
No. There are no steps to follow along with. Each lesson builds the mental model first, so when a tutorial (or your AI) tells you to do something, you already know what it is and why it matters.
Why are most lessons locked?
They are being made in order, one at a time, and each one unlocks here the day it is released. A lock only means "not released yet".
Where is the AI section?
There isn't one, on purpose. AI shows up in every district, so the lessons about it sit where they belong: coding agents with development environments, agents on git with Git, keys for agents with Trust. They carry a lantern on the map, and every other lesson says where AI shows up, when it does.
Do I need an account to watch?
No. Every released lesson plays right here in the browser, with captions, chapters and a transcript, and there is no sign-up. That also means the site has no idea what you have watched; it only shows what has been released.
How is each lesson made?
A crew of AI agents writes three versions of the script, picks and merges the best, fact-checks it, voices it with a narrator from the ElevenLabs voice library (a synthetic voice, different for every lesson), then animates and reviews it scene by scene. Every scene is animated in code; the title and end cards sit on one painted backdrop.