Courses

AI Literacy: Use It Well & Wisely

Get more out of AI without being fooled by it. Learn what tools like ChatGPT and Claude actually do, how to prompt them well, how to verify what they tell you, how to spot deepfakes and synthetic media, and how to use AI ethically and privately. Practical, cited, and non-hype: the trust foundation for everything else.

Free

AI Product: Idea to Shipped Tool (Capstone)

The Builder-track capstone: take one real problem and ship one real AI tool, end to end. You'll scope the problem and pin a success metric, choose the right approach (prompt vs. RAG vs. agent vs. fine-tune), design the UX and human-in-the-loop, build a thin MVP, add guardrails and an eval set, run a cost/latency/security review, ship with monitoring, then document and iterate, finishing with a capstone brief you could hand to a teammate. It synthesizes F2 (Building with AI) and B1 to B5 of the Builder track and carries the Learn.WitUS trust DNA throughout: cited, validated, honest, affordable. F2 and B1 to B5 are the recommended prerequisites.

Advanced Prompting & Reasoning

Go from getting answers out of AI to getting reliably good ones. This is the next step after AI Literacy (F1), for everyone, not just developers. You'll learn what a prompt really is and why structure matters, how to frame role/context/task/format, give examples (few-shot), ask the model to show its reasoning step by step, request sources and self-checks, and run the iterate-and-refine loop that turns a mediocre first answer into a strong one. Tool-agnostic and practical, with reusable prompt patterns for learning, work, and writing, and the trust DNA throughout: verify, cite, and remember that good reasoning can still reach a wrong answer. AI Literacy (F1) is the recommended prerequisite.

Building AI Agents & Automations

Go past the intro: build AI systems that take action. This is the technical, builder-track course for people who ship. You'll learn what an agent actually is (and the more common case where you DON'T need one), the plan-act-observe loop, how to do tool/function calling well, when a fixed workflow beats an autonomous loop, how to handle memory and state, and how to wire real multi-step automations with triggers, queues, and human-in-the-loop checkpoints. Then the parts that separate a demo from production: orchestration patterns (routing, chaining, parallelization, evaluator-optimizer), guardrails and least-privilege (the agent can take real actions: sandbox it, confirm it, limit its scope), evaluating and debugging with traces, and shipping with monitoring and cost controls. Carries the Learn.WitUS trust DNA throughout: an agent that acts is a security surface. F2 (Building with AI) is the recommended prerequisite.

Building with AI

Go from using AI to building with it. Learn what you can (and can't) reliably ship with today's models, how to turn prompts into working code, when to reach for no-code vs. an API, and how to build a real automation and a simple assistant. We connect AI to your own data with RAG, add guardrails, evaluate the output, and deploy it, all while carrying the Learn.WitUS trust DNA: verify, cite, and never ship slop. F1 (AI Literacy) is the recommended prerequisite.

Deploying & Evaluating AI Apps (LLMOps)

You built an AI feature. Now keep it trustworthy in production. This is LLMOps: the discipline of measuring, guarding, observing, and operating an AI app once real users depend on it. Build an eval set and run offline and online tests, use LLM-as-judge (and know when not to), add guardrails for injection, PII, and moderation, instrument tracing and cost/latency/token dashboards, make calls reliable with timeouts, retries, fallbacks, and caching, cut cost and latency, and ship responsibly with staged rollout, a kill switch, rollback, red-teaming, and drift monitoring. Throughout we carry the Learn.WitUS trust DNA: you can't improve what you don't measure, and you treat every model output as untrusted. F2 (Building with AI) is the recommended prerequisite.

Fine-tuning & Model Basics

You can prompt, retrieve, and orchestrate. Now learn when to change the model itself. This builder course demystifies how models learn (pretraining → post-training and RLHF), what fine-tuning really is, and the decision that matters most: when fine-tuning beats prompting or RAG, and when it's an expensive mistake. We cover the method families (full fine-tuning, LoRA/PEFT, instruction and preference tuning), how to build a real training dataset where quality beats quantity, the training loop and how to avoid overfitting, how to evaluate a fine-tuned model honestly, the cost/latency/hosting tradeoffs of API fine-tuning vs open weights, open vs closed models and their licenses, and the real risks: catastrophic forgetting, data leakage, and bias amplification. You leave with a 'should I fine-tune?' framework and the trust DNA to use it: evaluate honestly. Fine-tuning isn't magic. B1 (Prompt Engineering) is the recommended prerequisite.

L2: Detecting AI (Deepfakes, Synthetic Media & Provenance)

Synthetic media (AI-generated text, images, voice, and video) is now cheap, fast, and convincing. This course skips the 'count the fingers' tricks that stop working within months and teaches the durable skill instead: provenance and lateral reading. Learn how content credentials (C2PA) and watermarking (SynthID) work, and where they fall short; how to run reverse-image and metadata checks; how to shut down voice-clone and video-call scams with a callback; what the 'liar's dividend' is; and how newsrooms actually verify before they publish. Empowering and practical, honest that detection is imperfect, and cited to C2PA, Google DeepMind, the Partnership on AI, WITNESS, the FBI, NIST, and Stanford's media-literacy research. Builds on AI Literacy (F1).

L3: AI Ethics, Bias & Society

AI systems now help decide who gets a loan, a job interview, or a longer prison sentence, and they can quietly encode human bias while sounding neutral. This literacy-level course (no coding required) explains what "AI ethics" actually means, where bias comes from, why there is no single definition of "fair," who is accountable when AI causes harm, and how AI reshapes work, democracy, and the planet. You leave able to use and question these systems responsibly. Cited throughout (NIST, UNESCO, the EU AI Act, the ACM Code of Ethics, and the open Fairness and Machine Learning textbook).

L4: Data Privacy & Security in the AI Age

Your personal data is both the fuel modern AI runs on and the thing AI now makes cheaper to steal. This course teaches the durable habits that protect you: understand what counts as personal data and how AI tools collect, train on, and retain what you type; know exactly what NOT to paste into a chatbot (secrets, your own PII, other people's data, confidential work); understand your privacy rights at a high level (GDPR and CCPA) and how to exercise them; see why 'anonymized' data so often gets re-identified; and lock down the security basics (a password manager, multi-factor authentication, and phishing radar) now that AI has supercharged scams, voice clones, and social engineering. Practical and empowering, not fearmongering, and not legal advice. Cited to NIST, the FTC, CISA, the official GDPR and CCPA pages, and OWASP. Builds on AI Literacy (F1).

LangGraph in Production: The WitUS Triage Agent

Build a real production LangGraph agent, one small piece at a time. You start by learning when a linear chain has outgrown itself and you actually need a graph, then design a clean state contract, wire typed tools, and add a durable human-in-the-loop approval gate with interrupt() and a Postgres checkpointer. The second module crashes the process on purpose to prove the gate survives a restart, and shows the two rules that keep your own interrupts correct. It's grounded in the open-source WitUS Triage Agent code, TypeScript first with a Python durability track. Written to code along.

Multi-Agent LangGraph with Per-Agent RAG

Build one real multi-agent coach end to end, a LangGraph supervisor that routes each health question to the specialists that can actually answer it. Every specialist owns its own retrieval namespace, so a nutrition query never wades through workout documents, and each answer carries citations back to the snippets it was built from. You'll design the routing schema with Zod, guarantee ordering through the graph's shape, and isolate specialists by type so none can read another's findings, then measure routing, citation coverage, and grounding with LangSmith evals that gate every change. It's grounded in the open-source Centenarian Coach repo, TypeScript first with a Python translation track, and written to code along.

Prompt Engineering in Depth

The Builder track's deep dive into prompting as engineering, not luck. You finished Building with AI (F2); now you learn to design prompts the way you design code: system vs. developer vs. user roles, structured output and tool/function calling with schemas, few-shot example selection, chain-of-thought and self-consistency, ReAct-style reasoning, decomposition and prompt chaining, controlling determinism (temperature, top-p, seeds), defending against prompt injection, and (the part most people skip) evaluating prompts with real test sets, budgeting tokens, and versioning prompts in production. Assumes you write code and call model APIs. Trust DNA throughout: treat model output as untrusted; evaluate, don't vibe-check. F2 (Building with AI) is the recommended prerequisite; L1 (Prompt Engineering, literacy track) is the plain-language sibling for everyone.

RAG & Working with Your Own Data

Make AI answer over YOUR content (docs, policies, a product catalog, a knowledge base) without retraining a model. This is the technical, builder-track course for people who ship Retrieval-Augmented Generation (RAG). You'll build the whole pipeline: ingest and chunk your documents, embed them into vectors, store them (including in pgvector, which this app uses), retrieve the relevant pieces at question time, and assemble a grounded prompt. Then the parts that separate a demo from production: chunking strategy, retrieval quality (top-k, hybrid keyword+vector, re-ranking), context windows, and how to EVALUATE a RAG system: retrieval quality separately from generation quality, and groundedness above all. We cover the real failure modes (irrelevant chunks, stale data, prompt injection hidden inside documents), freshness and access control on your vector store, and the honest question most tutorials skip: when NOT to use RAG at all (RAG vs. fine-tuning vs. just-use-a-long-context-window). Carries the Learn.WitUS trust DNA throughout: a retrieved passage is evidence to ground and cite, never a fact to trust. F2 (Building with AI) is the recommended prerequisite; B2 (Agents & Automations) pairs well.

Reflection Loops in LangGraph: Write, Critique, Revise

You can build a LangGraph graph and call a model, but you haven't yet built an agent that judges its own output, revises it, and knows when to stop. This course builds that write, critique, revise loop one piece at a time on a running support-reply example, then hardens it: bounded termination so it always exits, a data rubric an LLM can actually score, LangSmith tracing that makes bugs legible, and an eval that reuses the very same rubric. Module 5 treats reflection as a budget on a cost and quality curve, and the capstone redeploys the whole stack on a brand-new domain (rewriting dense legal clauses into plain language) to prove the pattern transfers. It's TypeScript first with a Python translation track, grounded in the open-source wanderlearn-field-reporter repo, and every example runs offline with no API key. Follow along in the wanderlearn-field-reporter repo, and see the loop running in the deployed app.

Researching with AI (Cited & Verified)

Use AI to research faster without getting fooled. Learn what AI research tools can and can't do, why the hallucinated citation is the #1 risk and how to catch it, lateral reading and going to the primary source, how to judge source quality (who, when, why, funded by whom), how to use AI to find vs. to verify, how to synthesize without plagiarizing, attribution and APA basics (including how to cite AI itself), and how to build a verifiable research workflow with a source trail. Practical, non-hype, and cited to NIST, Stanford Civic Online Reasoning, APA Style, and a university library.