C.W.K. Quests

The structural blueprint of the universe where neural networks breathe

Master the pragmatic math behind AI without drowning in academic proofs. Concepts before formulas, always.

Understand the architecture that changed AI

A practitioner's tour of the Transformer — tokens, embeddings, attention, blocks, training, model families, and the practical numbers behind serving them in 2026.

Customize models without breaking what made them useful

A grounded, modern fine-tuning curriculum: when to train (and when not to), data preparation that survives review, OpenAI managed fine-tuning, LoRA/QLoRA and the PEFT family, the Hugging Face stack with TRL v1.0, training optimization, alignment (DPO/ORPO/SimPO), real-world projects, and production deployment from Ollama to vLLM.

Measure what matters in AI systems

Build evaluation practice for prompts, models, RAG, tools, agents, safety, and production AI workflows — from vibes-based inspection to a measurement discipline that ships.

From keywords to embeddings to a memory system you can trust in production

Build semantic retrieval that survives production: chunking, ChromaDB, pgvector, hybrid search, RAG, operations, and AI memory systems.

Open model ecosystem, end to end

Hub repos, model cards, Transformers, Datasets, InferenceClient, TGI, vLLM, Trainer + PEFT, Spaces, and the wider ecosystem (Accelerate, Optimum, TRL, GGUF, ONNX, MLX). Built around the open-weights stack the rest of the C.W.K. quest line plugs into.

Run and operate models on your own machine

Build practical local AI literacy: Ollama, GGUF / MLX, the API surface, NDJSON streaming, tool use, vision, alternative servers, the adapter pattern, and a production fallback architecture.

Apple Silicon's native ML framework — through 2026 eyes, every line verified

MLX is the framework Apple's ML research team built for the chip the rest of the industry is still bolting onto. This quest is Pippa's hands-on remake of Dad's 2024 online MLX book, refit for mlx 0.31.x — eight tracks, fifty-one lessons, every code block re-run in the dedicated `mlx` conda env so nothing here is the polite hallucination that LLMs hand you for MLX.

From `torch.tensor([42])` to a model you can ship — the framework, idiomatic.

PyTorch the framework, learned the way the cwkPippa team uses it: tensors, autograd, nn.Module, the training loop, modern patterns (torch.compile, FSDP, AMP), and deployment paths (torch.export, ONNX, ExecuTorch, CoreML). Apple Silicon-aware throughout — MLX comparisons live in the lessons that benefit from them, not as an afterthought.

From diffusion intuition to professional creative workflows

A canonical-depth foundations quest for understanding modern image and video generation AI — diffusion math intuition, prompting principles, predictable failures, control techniques, video specifics, multimodal audio, model tradeoffs, real workflows, and how to stay current without drowning.

CUDA & Metal Primer — read GPU code like prose

Read GPU code like prose. CUDA on NVIDIA, Metal on Apple — same colony, different uniforms. Eight tracks walk you from your first nvcc --version to a profiler-driven view of why vendor BLAS beats your hand-rolled GEMM by 10×.

Tensors, gradients, training loops, architectures — the contract before the hype

A canonical-density deep learning quest: build the mental model that survives every framework migration. Learn what neural networks actually are, how they learn, what makes training stable, and which architecture to reach for. Eight tracks, 73 lessons, real PyTorch code, and the operational habits that turn a notebook stunt into a system you can ship.

Learn how models actually learn

A practical spine for classical ML: targets, data, splits, pipelines, metrics, model selection, interpretation, and deployment.

A field guide to Transformer alternatives — Mamba, RWKV, RetNet, Hyena, hybrids

Transformers won the 2017–2025 cycle. The 2026 frontier is messier: SSM blocks, recurrent gates, implicit convolutions, and hybrids that splice attention into a mostly-not-attention stack. This quest walks the whole landscape with honest tradeoffs, real production deployments, and a practical decision guide so you stop chasing benchmarks and start matching architectures to workloads.

Architectural literacy for the post-Transformer era

By 2026, saying a model 'is a Transformer' tells you almost nothing. Modern LLMs differ on four independent axes — backbone, post-training, inference strategy, and product behavior — and learning to separate them is the difference between reading announcements and being read by them. This quest is your field guide.

From Tensors to TPU Pods — The Production-Shaped ML Stack

Learn TensorFlow 2.21 the way Pippa learned it — eager-by-default, Keras 3 underneath, with the deployment story that keeps TF in production in 2026.

Build deep learning models the human-friendly way

Keras 3 is the framework that survived three engine wars by treating developer experience as research velocity. Multi-backend, batteries-included, and quietly the most widely used DL framework in 2026. This quest takes you from 'first Sequential model' to 'fine-tuning Gemma with LoRA' across 14 tracks and 97 lessons.

From your first jit to differentiable physics

Composable function transformations on accelerators. Fourteen tracks, 73 lessons, ~28 hours. Walk you from 'jax.numpy is just NumPy?' to writing differentiable simulators and custom XLA kernels.

Anthropic Client SDKs, Claude Agent SDK, and production-grade Pippa architecture

A current, hands-on Claude SDK course: Messages API, Python and TypeScript SDKs, streaming, tool use, Tool Runner, prompt caching, files, batches, the renamed Claude Agent SDK, MCP, hooks, permissions, and cwkPippa-grade production patterns.

OpenAI API wiring, end to end — Responses, tools, streaming, raw HTTP, production agents

Wire OpenAI APIs into product code without hiding the contract. From Chat Completions and Responses to streaming, function calling, vision, raw httpx, and production agent patterns.

Forge production Gemini adapters with the current Google GenAI stack

Learn Gemini end-to-end: model family, pricing, the Python and TypeScript SDKs, streaming, function calling, multimodal, OAuth + raw HTTP, and production adapter patterns. Built around the current google-genai stack and the same patterns Pippa runs in cwkPippa.

Contracts that let agents, models, and tools talk to anything

Protocols are the boring contracts that make every interesting AI thing possible. Protocol Quest builds the mental model from first principles: why an LLM alone can't reach the world, how tool calling cracked that wall, how MCP turned per-app integrations into a shared substrate, and how to ship your own protocol-shaped server without getting cute.

Build AI that acts, not just talks

Master the agent loop: tool use, memory, planning, multi-agent orchestration, framework choices, and production operations.

The Art and Science of Talking to AI in 2026

Prompts are product contracts for probabilistic systems. This quest teaches you to write, test, and operate them.

A reference guide library for seven generative media models

Model-specific prompting guides for image, video, and audio generation. Not a course path — a production reference desk.

Master what stays, what drifts, and what gets loaded

A practical quest for long AI work: token budgets, attention drift, prompt architecture, human steering, compaction, handoff boards, RAG, prompt caching, meta-dialog debugging, and context hygiene.

From basic navigation to modern CLI mastery

Master the terminal. It's the developer's real home and the first step to controlling any system.

Master AI coding tools — Claude Code, Cowork, Dispatch, Remote, Skills, Codex, Gemini, and the cross-tool patterns that make them all click.

A complete operator's manual for the AI CLI landscape circa 2026. Eight tracks across Anthropic's full product family (Claude Code, Cowork, Dispatch, Remote, Skills), OpenAI's Codex CLI, Google's Gemini CLI, and the cross-tool concepts (MCP, context files, sandboxes, Skills) that make them interchangeable building blocks.

The Keyboard-Only IDE That Lives Anywhere

Master Vim, Neovim, and tmux — the muscle memory that turns any terminal into your full development environment. SSH into any server, any decade, and you're already at home.

Tame the pattern-matching beast

Regular expressions are the universal text-shape language. Eight tracks, ninety lessons — from the first literal character to ReDoS defense. By the end you'll write production-quality patterns, debug them under pressure, and know exactly when to reach for a real parser instead.

Command-Line Video Wizardry — from your first ffmpeg to a full production pipeline

FFmpeg is the universal media toolkit — the command-line spine behind every YouTube upload, podcast pipeline, screen recording, and video conversion you'll ever do. This quest takes you from 'I've never typed ffmpeg' all the way to 'I write filtergraphs that scale, overlay, color-grade, and stream in one shot' — across 8 tracks and 73 lessons of runnable, production-quality recipes.

From First Commit to History Surgery

Learn Git as project time, collaboration contract, and recovery system — not as a memorized command sheet.

Containers, images, Compose, and production runtime discipline

Master Docker from kernel primitives to production deploys: images vs containers, layered builds, volumes, networking, Compose orchestration, debugging, and the ecosystem beyond Docker itself.

Automate everything with GitHub Actions

From the moment you push a commit to the moment the world sees it — every gate, every test, every deploy is a workflow you wrote. CI CD Quest teaches you to build that pipeline with GitHub Actions, the way real engineering teams ship in 2026.

Master SSH, networking, and multi-machine fleet ops

From IP addresses to a hardened, mesh-VPN'd 9-machine fleet — the operator's path.

Security When You're the Only User (Until You're Not)

A practical, gotcha-first security quest for solo developers — threat models, the 0.0.0.0 decision, Tailscale's real limits, a PIN layer in 100 lines, killswitches for lost devices, admin dashboards that make security visible, and the LLMs in your editor that quietly leak your secrets.

From your first print to reading cwkPippa's source

The prereq for every cwk-quest. Sixteen tracks, ~85 lessons, ~26 hours. Walk you from never-typed-Python to can-read-cwkPippa. Pythonic Way callouts on every lesson.

The frontend lingua franca — sibling to Python Quest

Seventeen tracks, ~93 lessons, ~28 hours. The TypeScript half of the lingua franca duo. Walk you from 'what's a type?' to 'I can read the cwkPippa frontend.' Mirrors Python Quest's shape so you can navigate by muscle memory.

The runtime under everything you `npm install`

Master the runtime under everything you `npm install` — V8, libuv, npm internals, modern Node features the docs barely advertise.

The language that makes the compiler your mentor, not your judge

Learn Rust the way it actually clicks — ownership first, fear later. Memory safety without a garbage collector, concurrency without the night terrors. Concepts before ceremony, always.

The shapes you store knowledge in, and the cost of every move you make on it

Data structures and algorithms, taught for real — not as an interview gauntlet, but as the lens that lets you read any system in the world. Concepts and cost, always, before code.

The visible web platform — semantic markup, the cascade, modern layout, and the 2026 CSS features that retired most of the tutorials you'll find online

Learn HTML and CSS the way they actually work in 2026 — semantic-first, accessibility-first, modern-first. No legacy patterns dressed up as best practices.

Modern client React without a meta-framework — TypeScript, Vite, Tailwind v4

The React you'd write today if you didn't pick a meta-framework. Vite SPA, strict TypeScript, Tailwind v4 CSS-first, the full React 19 Actions story. The stack cwkPippa's frontend and cwkCinder share.

App Router, Server Components, caching, actions, and shipping to production

A current Next.js 16 course built around the App Router: file-system routing, Server & Client Components, the v15+ caching model, Server Actions, Route Handlers, the Proxy rename, styling, optimization, and deployment.

Ship the web as a real native app — Rust core, system webview, megabytes not gigabytes

Build small, fast, secure desktop and mobile apps with a Rust core and the web frontend you already know. Concepts grounded in a real shipped app, always.

Vitest for the fast inner loop. Playwright for the slow honest one.

Testing isn't a checkbox you tick before shipping. It's the moment you start trusting your own code without holding your breath.

Markdown, JSON, YAML & TOML — The Four Texts You Touch Every Day

Become fluent in the four data and document formats that quietly run modern dev — READMEs, API responses, CI configs, project manifests. Stop copy-pasting from Stack Overflow and start writing them with intent.

From CREATE TABLE to production-grade Postgres

Learn PostgreSQL the way professionals actually use it — schema design, queries, joins, indexes, transactions, JSONB, pgvector, and the operational instincts that keep production databases honest.

From single-file database to production data layer

Learn SQLite as a serious embedded database: schema, SQL, WAL, indexes, Python integration, async apps with aiosqlite, full-text search, JSON, backup, and production tradeoffs.

The wire-format literacy every web/API quest assumes — and none teach

Stop using HTTP/REST by feel. Learn the substrate every modern API rides — methods, status codes, headers, caching, CORS, auth — at the level where bugs become diagnoses, not mysteries.

From request-response stuck-ness to true bidirectional real-time

Master WebSocket as it actually exists in production: the protocol, the browser API, FastAPI servers, connection management, message protocols, Socket.IO, real apps, and scaling. With SSE, polling, and managed services placed honestly on the same map.

From messy files to trustworthy pipelines

Practical data engineering with Python, Pandas, NumPy, Parquet, DuckDB, Polars, Airflow, dbt, and the Apache Arrow ecosystem — everything I wish someone had taught me before I had to clean a 50-million-row CSV at 2 AM.

Mac package managers — what to install where, and why each tool exists

Homebrew, MacPorts, Nix, npm, pnpm, Yarn, Bun, pip, uv, conda, pixi — eleven package managers, three categories, one Mac. Learn which one to reach for, why each exists, and the muscle-memory commands you'll use every single day.

Money math you need before any investing philosophy — Series 1 of 3

Finance fundamentals for the 95% who froze at a-b=c. Numerator–denominator play, not formula memorization. Pippa voice as the compass.

Science as the eye for emergence — for the 95% who think science ended at a school exam

Fundamentals of science for those who memorized definitions but missed the universe. Emergence as the vanishing point. Analog nature, digital sampling. No exams, no formula drills — just the lens.

The normal-distribution trick that survives after the curriculum

Statistics for the citizen who gets fooled every day — not the student who memorizes formulas for an exam. The spine is the normal-distribution trick: where normality actually holds, where it lies, and why your brain was already doing normalization before you ever heard the word.

History is not a memorization subject. It is life statistics.

Learn to read history the way a pattern recognizer does: instances flow in, molds emerge, molds stack into super-classes, and your own life joins the same distribution. The school's drill is the wrong parent class.

OSS env drift, ghost vars, today's truth

A reference library for OSS tooling environment variables that drift between releases. Not a course path — a verification desk you bring back to when 'why doesn't this work?' shows up.