13 tracks and growing. 452 lessons, with more every week.
Start at Foundations and work down, or go straight to the model you already use. Everything is visible from the start — no drip feed, no unlocking, no waiting a week for the next module.
Foundations
Before any model. What AI is and how it got here, who makes what in 2026, the words you need, how it fails, what it costs, what never goes in — and the habits of someone who uses it well: judging and interrogating answers, getting a real critique, second opinions, grounded research, a prompt library, a weekly spend review, staying current, and teaching a model your context once.
Claude
The deepest track, written for someone becoming an AI engineer. The three ways in and the models; the machinery; Claude Code properly. Then the whole platform: the Messages API contract, every tool Anthropic runs and every tool you run, tool search and programmatic calling, the MCP connector and Skills, context management and citations, the Agent SDK, Managed Agents, evals, CI, the cloud platforms, and governing an organisation's Claude.
OpenAI
ChatGPT and the platform behind it: the GPT-5.6 family and GPT-6 Astra, every plan and what it really unlocks; ChatGPT properly (projects, memory and custom instructions, canvas and data analysis, deep research, ChatGPT Work and the cloud browser that replaced agent mode, apps and plugins, voice); building on the Responses API (items and conversation state, streaming and background mode, tools and function calling, structured outputs, hosted file search, images and files, Batch, Flex and caching with worked numbers, usage tiers and retries); Codex, custom GPTs and media; and prompting GPT from the first message to reasoning effort, verbosity, the chain of command, evals and migrating a prompt to a new generation.
Grok
xAI's models: Grok 4.6, 4.5, 4.3 and Grok Build; the real-time angle with server-side web and X search; Grok inside X, the app and the web app; Imagine images and video; the API in depth — tools, structured outputs, live search in code, media, rate limits and cost; the Grok Build coding agent; prompting and limits.
Gemini
Google’s models at full depth: the 3.x Flash line and 3.1 Pro, every plan and the free tier’s real terms, AI Studio, Nano Banana and Veo, then Gemini across Google — the app’s Gems (built, shared and versioned), memory, Deep Research, Canvas, Workspace, Android, Chrome and NotebookLM — and the builder’s layer: the Gen AI SDK and the interactions endpoint, streaming and thinking levels, function calling and JSON schemas, the Files API with real token maths for documents, audio and video, Search grounding and URL context, then caching, batch, rate-limit tiers and the move to Google Cloud.
Open source and self-hosted
Run open models yourself: the hardware maths, the tools (Ollama, LM Studio, llama.cpp, vLLM, Hugging Face), one lesson each on Hermes, OpenClaw, Kimi and Qwen, then the harder decisions — buying or renting a GPU, fine-tuning, licences, a fully private local agent, and the model families you will keep hearing about.
Images and video
Every image generator and every video model taken one at a time — setup, real prices, what each is genuinely best at, its prompting quirks, editing and references — then video done properly: storyboard, first frames, takes, upscaling, the cut, and the rights and disclosure rules that keep you out of trouble.
Voice
Everything spoken: text-to-speech, cloning with consent, ElevenLabs, OpenAI and Gemini tool by tool, open-source voice on your own machine, transcription you can trust, realtime agents, dubbing and captions that meet the standard — with what each one costs.
Building things
Where the tracks combine into something real: the shape of an AI product and the agent loop; the stack (Workers, Supabase, row-level security, accounts, Stripe, environments and secrets); the intelligence (retrieval end to end, embeddings and hybrid search, grounding and citations, evals, caching and cost control); the channels (a web widget, SMS and WhatsApp, email, Slack and Discord, scheduled jobs with a human approval gate) — and your capstone.
Getting paid
The bridge between being able to build and being paid to build: the handful of jobs businesses buy over and over and what each is worth; pricing, deposits and staged payments; finding the first clients with no employment history, no brand and no network; the discovery call, the one-page proposal and the clauses that protect you; delivering with milestones and handing over cleanly; what may and may not happen to a client's data; support, retainers and invoicing; and turning the same build repeated five times into a product.
Debugging
The skill every tutorial skips, taught to engineer level. Reading a failure; the method — reproduce, halve, one change at a time; the browser and runtime debuggers used properly; debugging AI systems and debugging WITH an AI agent without getting stuck in its loop; the front end's caches, CORS and expiring tokens; the back end's logs, Postgres errors and deploys that did not land; races, idempotency and caches; performance; and gates that catch a whole class of bug so it never comes back.
AI security
Protecting what you build, and protecting people from it. The attack side in full — injection through every channel, keys, least privilege and approval gates, data, RLS, auth and webhooks, supply chain, red-teaming and incident response. Then AI safety for an AI specialist: the frontier threat models, Responsible Scaling Policies, dangerous-capability evals, reward hacking, sycophancy, alignment faking and agentic misalignment, AI control and monitoring, interpretability, constitutional methods, safety cases and the safety architecture of your own agent.
MCP — building servers that give an AI real tools
The Model Context Protocol from the wire up: what it standardises and what it deliberately leaves alone; the shapes a server exposes and who controls each; stdio and Streamable HTTP; a first server called from a real client; how to design a tool a model can actually use — the description, the schema, the result, the error; resources, prompts and completion; state, long jobs and change notifications in a protocol with no sessions; installing a server into Claude Code, Claude Desktop, Codex and your own code; the security of a hole you punched in your own machine; testing, publishing and surviving a specification that moves; and four real servers built end to end.
Read it, build it, prove it.
-
Read the lesson
1,400 to 2,200 words that go to the mechanism, with every fact sourced to the maker's own documentation and the date it was checked. Highlight any sentence and ask about that exact line.
-
Do the exercise
One step of one continuous build, ten to thirty minutes, ending in a named file that still exists tomorrow. It works whether or not you tell anyone what you are building.
-
Take the test
Get one wrong and it explains the exact thing you missed, then writes a new question on the same idea. Your skill map fills in per concept and per model, so you can see what is actually solid.
-
Run it in the playground
Every lesson has a live playground. Run your prompt against two vendors at once, see both answers, and see what each one cost.
-
Watch it happen
Each lesson is also filmed. The video sits on the lesson page and on YouTube, including the parts where it goes wrong.