Learn
721 lessons · 85 tracks · 9 practice tools
Tracks
The Operator's Mental Model
The mindset that separates operators from casual users. See AI as an operating system — persistent, routed, and compounding — before you build anything.
From Zero to Your First Project
From zero to your first web page — install Claude Code, learn the core workflow, and ship your first project with AI as your copilot.
The Art and Science of AI Communication
The art and science of communicating with AI — write prompts that get results, build system prompts that shape behavior, and master the techniques that separate operators from novices.
The Playbook for Prompt Engineers Who Want This Week Better
Ready-to-adapt prompt patterns organized by job function, not technique — writing, research, analysis, decisions, extraction, planning, learning, and iteration. Each pattern ships with its failure mode. Reference Prompt Engineering Mastery when you need the craft theory underneath.
The OpenAI Ecosystem from API to Production
The OpenAI ecosystem from API to production — master GPT-4o, o1, function calling, structured outputs, Assistants API, and the patterns for building reliable OpenAI-powered applications.
Google's Multimodal Powerhouse
Google's multimodal powerhouse — master Gemini 2.5 Flash, 2.5 Pro, and the Gemini 3.x preview tier, harness the 1M token context window, process images/audio/video natively, and build production pipelines with the Gemini API.
From Prompt to Pixel
From prompt to pixel — master GPT Image 2 as your primary production model, build fallback chains across Gemini, Leonardo, and Stable Diffusion, and learn the craft of visual prompting that separates operators from amateurs.
Your Entry Path Into AI Video — One Tool, One Real Clip
A lite, honest on-ramp into AI video: what today's models can actually do, the four-layer prompt framework, one real clip made end to end with Google's Veo, the craft habits that keep a clip from looking like AI slop, and the shape of a real production pipeline — concepts only. Built as the entry path into Pro's deeper video-generation track, which covers five platforms and a real running pipeline.
From Script to Screen with AI
From script to screen with AI — master Veo, Sora, Runway, HeyGen digital twins, and the production pipelines that turn ideas into published video content without a film crew.
From a Chat Window to a 24/7 AI Employee
The clearest on-ramp into agentic AI — climb the seven-level ladder from a single chat window to a persistent, self-running agent. Messaging, skills, cron, multi-agent boards, memory, and agent-as-MCP, explained for anyone starting out.
The Protocol That Let AI Touch the Real World
Model Context Protocol, explained in plain language — no coding required until the optional build lesson, where you read along with a tiny ~20-line server. Understand the three primitives, connect your first server, learn the read-vs-write safety line, and see the real servers that give an AI memory, messaging, and search.
Why Your AI Forgets — and How to Fix It
Every AI user has felt it: the model forgets everything between sessions. This track explains the problem plainly and walks you from context windows to a personal knowledge OS — RAG vs. structured facts, trust scores, the query-first habit, and memory hygiene.
Make AI Use the Web for You
The most tangible win for a newcomer: an agent that browses and acts on websites. Taught through the Conductor Stack mental model — conductor, agent, skills, OS, output — with community-maintained skills instead of brittle custom scrapers.
Source → Draft → Image → Publish, on Autopilot
A build-something-today track. Assemble a four-stage content pipeline with a human-in-the-loop publish gate — the exact pattern that runs this very blog. Source topics, draft in your voice, generate hero images with a fallback chain, and ship via Git PR.
The AI OS Mental Model
Build the mental model that separates operators from casual users. Understand AI as an operating system — persistent, routed, and compounding.
Building the Platform
Set up the persistent agent platform, MCP servers, memory layer, watchdogs, and the full service architecture that runs 24/7.
Pipelines That Run Themselves
Build content flywheels, cron-AI pipelines, model routing, and git-based deployment — systems that produce output while you sleep.
The Rules That Scale
The operational rules that prevent catastrophic failure: stop-and-replan, E2E validation, compound learning, security, tooling discipline, and ticket hygiene.
Beyond the Basics
Beyond the basics — MCP servers, hooks, parallel agents via worktrees, CLAUDE.md mastery, remote sessions, and the operational patterns that 10x your output.
The Operational Layer
The operational layer that separates power users from everyone else — hidden settings, hook architecture, model routing, subagent configuration, agent teams, and fleet deployment across machines.
Build Your 24/7 AI Employee
From chatbot to employee — install OpenClaw, wire up Discord and Telegram, build your first automations, design a Skills library, architect persistent memory, and ship Mission Control. Eight lessons from someone who actually runs this in production.
The AI Agent in Your Terminal
GitHub's terminal-native AI agent — install it, master the session workflow, wire custom instructions, use plan mode for complex tasks, delegate async work, and set up your team for production use.
Build AI Products That Actually Scale
You validated the idea. You ran the cost math. Now build it correctly — the architecture patterns, prompt caching, observability, and iteration loops that separate AI products that scale from ones that collapse under their first real users. Course 2 of the AI as SaaS series.
From Idea to Viable Business
You probably built something you can't sell, or you're thinking about building something you haven't proved anyone would buy. This track covers the part nobody else teaches: idea pressure testing, real AI operating costs, and the architecture gaps that prevent vibe-coded apps from ever becoming businesses.
From Single-Agent to Fleet
From single-agent to fleet — design orchestration layers, coordinate parallel agents, manage shared state, and build systems where AI agents hand off work to each other.
The Framework for Running AI Autonomously
The framework for running AI autonomously without babysitting — validation agents, swarms with consensus, code review agents, confidence scoring, escalation protocols, and kill switches. Trust is earned, not assumed.
Intelligence as Modern Prophecy
Competitive intelligence as modern prophecy — build AI-powered systems that monitor markets, extract signals from noise, track competitor moves, and synthesize intelligence into decisions.
Claude Certified Architect — Foundations
Prepare for the Claude Certified Architect — Foundations certification. Master all five exam domains: agentic architecture, tool design & MCP, Claude Code configuration, prompt engineering & structured output, and context management & reliability. 60 questions, 720 to pass, zero shortcuts.
Ship Code That Actually Works
The testing discipline that let us fix 100 bugs across 11 projects overnight — autonomously. Quality gates, E2E testing, Playwright as development eyes, multi-agent code audits, visual QA retros, and the delivery checklist that separates shipped from broken.
Build First, Adopt Second
We build 90% of our tools from scratch. Not stubbornness — sovereignty. Learn the framework for deciding when to build, when to adopt, how to security-scan, how to wrap external tools without creating dependency, and how to maintain exit strategies.
AI-Native Engineering Discipline
The engineering discipline that separates builders who ship from builders who generate. Quality checkpoints, testing that catches real bugs, CI/CD as enforcement, structured debugging, the Two-AI Architecture, and incident response — taught through real production war stories.
The Invisible Tax on AI Development
The compound cost of neglected repos: bloated CLAUDE.md files burning tokens on every agent session, stub test files gaming quality gates, and CI jobs wasting minutes on every PR. Six lessons covering the 200-line rule, stub detection, CI cost engineering, and the systematic audit workflow — taught through real production examples.
Find What Agents Miss
Six self-contained patterns for finding and fixing bugs at scale with AI agents. The 3-role audit swarm, tested-but-unwired dead code, fail-open defaults, verify-before-fix discipline, autonomous overnight runs, and integration guides as first-class outputs — each a standalone pattern drawn from real production audits.
The Nervous System for AI Agent Fleets
Build the connective tissue that lets AI agents talk to each other — deterministic routing, org-based authority, audit-before-dispatch, and the SDK pattern. Drawn from a real production broker running 24/7.
The Rules That Prevent Catastrophe
Authority ceilings, escalation over hard blocks, a 4-level kill switch with CLI fallback, recovery protocols, and the non-negotiable 100% safety test coverage rule. Built for the 2am incident you hope never comes.
Never Get Surprised by an LLM Bill Again
Per-agent daily budgets, model tier routing, loop detection, cost attribution events, and the CFO daily report — the complete FinOps stack for autonomous AI agents. Prevent the $200 weekend before it happens.
Treat Agents Like Employees — With Performance Reviews
Reasoning traces, behavioral baselines, drift detection, goal alignment, decision replay, and the automated 1:1 protocol — the observability stack that treats AI agents like real employees with real performance reviews.
84 Findings to Zero in One Session
The methodology that resolved 84 code audit findings across security, architecture, performance, and testing in a single session — audit swarms, prioritized fix order, parallel agent dispatch, CI gates, and the math of compound velocity.
The Silent Failures Behind a Healthy Status Page
Ten hard-won lessons from operating a multi-machine homelab over Tailscale — merge gaps, lying health checks, exponential drift, permission bombs, ghost processes, network ambiguity, Docker caching traps, singleton enforcement, version observability, and building automated drift detection. Every lesson draws from a real incident.
Build a Production Agent Operations Platform
The blueprint for turning a collection of isolated AI sessions into a production-grade operations platform — persistent expertise, team architecture, organizational wiring, authority delegation, behavioral health monitoring, and the complete end-to-end system.
From Cookies to OAuth to Cross-Domain Sessions
How authentication ACTUALLY works — from cookies to OAuth to cross-domain sessions. Every lesson uses a real production debugging journey as the running example: the April 2026 incident that took 12 PRs and 8 hours to resolve.
Build scoring systems that actually fire
Component weighting, fire-rate monitoring, ceiling analysis, arithmetic backtesting, and the math that prevents dead components from silently killing your signal. Drawn from the agent framework score rebalancing that took a bot from 2,646 signals and zero trades to live in one session.
CLOB integration from first principles
The Polymarket CLOB integration layer demystified — FOK vs GTC, USDC.e collateral, EOA signing vs proxy wallets, balance guards, and the semantic matching patterns for consensus-based calibration. Everything you need to build a prediction market bot that doesn't silently fail.
Distribution kills assumption
The debugging discipline that turns a 2-hour fix into a 30-second one. Pull the data before designing the fix. Hypothesis-driven queries. Multi-checkpoint verification. The exact workflow that Knox used to diagnose the agent framework calibrator problem in 60 seconds of SQL.
Specs that eliminate clarification round-trips
How to write sub-agent specs that return working code on the first try. File paths, line numbers, scaling factors, acceptance criteria, backtest methodology — the anatomy of a gold-standard spec, drawn from the agent framework PR #28 delegation that took a scoring rebalance from concept to merged PR with zero back-and-forth.
When broken looks exactly like healthy
Dead components, wrong addresses, stale configs, backtest/live drift, proxy/funder footguns. The failure modes that don't throw errors, don't log warnings, and don't page oncall — they just silently return zero and let the system keep running on empty. Detection patterns for each.
Operational validation as a distinct discipline
Test coverage measures code integrity. Operational validation measures whether the system produces its intended outcome. The gap between them is where the best-tested bot in the ecosystem goes 3 weeks without placing a trade. This track is the cultural correction.
Evaluation, Audit, and Quality Assurance for AI Pipelines
Design evaluations for agent outputs, run audit swarms, handle knowledge cutoff as a testing concern, and build LLM-as-judge systems for automated quality scoring. Drawn from real audit runs across Knox's fleet — including the SP-001 false positive incident and the Autoresearch prompt quality system.
Production Agent Infrastructure from Anthropic
Anthropic's hosted agent harness for async production pipelines — define agents, provision environments, stream session events, orchestrate multi-agent workflows, and apply production-grade versioning and cost discipline.
Give Your AI Eyes
Close the biggest gap in AI-assisted development: Claude Code builds blind. Pair it with visual AI companions — Claude Chrome extension, claude.ai screenshots, and computer-use MCP — to create a closed-loop visual QA workflow where nothing ships without being seen.
Customizing the Claude Code Harness
The Claude Code harness is yours to shape — settings.json for mechanical enforcement, hooks for deterministic event reactions, skills for load-on-demand expert workflows, slash commands for versioned prompt shortcuts, and CLAUDE.md for semantic context. Master all five layers and the curator discipline that keeps them compounding.
From Beginner MCP to Servers You Run 24/7
The gap between a demo MCP server and one you trust at 3 AM is six engineering dimensions. Build the full production stack: HTTP transport, bearer token auth, scoped access, structured observability, read/write safety gates, and the audit lab — modeled on Knox's semantic memory layer (12 tools, 414 tests, 92% coverage, running 24/7 on a persistent server).
Fan Out Work Without Collisions
From serial bottleneck to agent fleet — learn to dispatch 5 agents simultaneously, isolate them with git worktrees, converge without collisions, and verify with a 5-agent code-review-swarm. Drawn from Knox's production orchestration patterns across 67+ repos.
From Idea to Shipped, Spec-First
The spec is the contract with the agent — learn to write PRDs that eliminate scope ambiguity, decompose masters into parallelizable phases, feed specs to the /ship pipeline, and compound every delivery into a better next spec via the retro → lessons → semantic memory layer loop.
Docs Are the Agent Interface
In agent-driven development, documentation stopped being a chore and became the operating interface — agents read your docs at the start of every session, so doc quality now sets the ceiling on agent output. Master the full stack beyond the PRD: READMEs, agent context files, ADRs, runbooks, learning loops, contract docs, and the CI gates that keep them alive.
Build the Layer That Actually Runs the Model
Context is the dominant lever — more impact than model selection, prompt wording, or tools combined. Master CLAUDE.md architecture, progressive disclosure, semantic memory with semantic memory layer, context rot detection, and the full playbook for a system that compounds with every session.
Source → Draft → Image → Publish, on Autopilot
The step up from your first pipeline: reliability, scheduling, state, and self-healing that make content run every Monday, Wednesday, and Friday without you. Drawn from Knox's blog-autopilot, AI content production pipeline, and devlog-engine — real systems that publish at scale.
Make AI Build Interfaces That Don't Look AI-Generated
The constraint system that makes AI produce distinctive, on-brand UI instead of generic templates. From extracting design tokens to the master prompt, surgical iteration, and Playwright visual verification — the full production workflow for AI-assisted frontend work.
Root-Cause Discipline for Agents & Pipelines
The debugging discipline built from real incidents in Knox's AI fleet — zombie pipelines, split-brain instances, concurrent-agent git collisions, dead scoring components, and context pollution. Scientific method, hypothesis logs, gate chains, and the regression-test-first rule that makes debugging compound over time.
From 'It Runs on My Machine' to an Observable, Autoscaled LLM Service
A working prototype is 20% of production. This Elite masterclass teaches the deploy-and-operate layer most operators skip: containerize an AI service, orchestrate it on Kubernetes with GPU scheduling, serve an LLM with vLLM, provision it with Terraform, and prove it healthy with SLOs and error budgets — ending in a graded end-to-end capstone. Inference-first, single-stack, grounded in Knox's real systems (semantic memory layer, Mission Control, and a persistent server). Curriculum scaffolding inspired by the open-source AI Infrastructure Engineer Learning track (VeriSwarm.ai, MIT); all lessons, diagrams, and examples are original.
Ship Code with OpenAI's Agent
From zero to shipping with OpenAI Codex — the agent that reads your repo, edits files, and runs commands. Install the CLI, learn the agent loop, wire up the Responses API, and ship a real feature with approvals and AGENTS.md keeping you in control. The API lessons near the end use short TypeScript examples, so basic JavaScript/TypeScript familiarity helps (a Python path is signposted).
The Anthropic API from First Call to Production
Build directly on the Claude API — the Messages API, the tool-use loop, structured outputs that survive the real validator, prompt caching economics, adaptive thinking, and the Batch API. Ends with a tool-using integration hardened by typed errors, a usage ledger, and a deploy-time smoke gate.
Retrieval Systems That Show Their Receipts
Build retrieval-augmented generation that holds up in production — gated corpora, structure-aware chunking, vector indexing with a re-embed lifecycle, tuned retrieval, cited answers that refuse when retrieval is thin, golden-set evals, and the ops layer: cost, latency, injection defense, and access control.
Build the Memory Layer Where Corrections Compound
Build persistent memory for AI agents — the capture, index, recall, and lifecycle architecture that makes agent quality compound across sessions instead of resetting. Memory taxonomy and provenance, dedupe-gated write paths, progressive-disclosure recall, namespaced authority, hygiene (supersede, expire, verify-before-trust), budgeted session hydration, and the health metrics that prove the loop is working.
Docs as Automated Artifacts
Stop maintaining docs by hand — make them maintain themselves. Drift detection that tests docs like code, generated references with one source of truth, doc-updating agents on a safety model, runbooks verified in CI, autopilot changelogs, doc registries, and the freshness SLOs and blocking gates that make stale docs unmergeable.
Locking Down the Stack Attackers Want Most
Your agent stack is a new attack surface — credentialed, always-on, and programmable in plain language. Lock it down: secrets hygiene when agents touch env files, blocking gates for topology and PII leaks, direct and indirect prompt injection defense, least privilege, the attacker's kill chain, and the modern CAPTCHA layer that breaks the economics of mass automation.
Plain-Language AI for Non-Technical Work
The plain-language on-ramp to AI for any profession. No code, no jargon — just the mental model, how to actually ask for what you want, how to pick a tool, and the honest limits that keep you out of trouble. Built for people who suspect AI matters but were told coding isn't for them.
Build One Tiny Thing That Actually Runs
The free starter that turns "I could use AI" into "I just did." In three short lessons you describe what you want, your own Claude writes it, and you run it on your own machine — then ship proof of your first working tool. No setup gauntlet, no jargon, no coding experience assumed. The academy never runs your code; you build with your own Claude and submit proof it runs.
One Idea, Everywhere
Turn one idea into everywhere your audience lives. A no-code free track for content creators: the content multiplier, a realistic AI workweek, the honest limits that protect your voice, and a capstone where you ship a real six-format content kit. You bring the idea; AI brings the reach.
More Time With People, Less With the Pipeline
A no-code track for recruiters and talent teams. Let AI carry the repetitive pipeline — job descriptions, sourcing, screening drafts, scheduling, candidate updates — so you spend your time on judgment and relationships. Includes the fairness and human-in-the-loop rules that keep AI hiring legal and honest, and a capstone where you ship a complete hiring kit for one role.
Bill for Outcomes, Not Hours
A no-code track for management and strategy consultants. Let AI carry the scaffolding — data-room research, interview synthesis, first-draft decks, proposals — so you spend your time on the judgment clients actually pay for. Learn the engagement flywheel that turns every project into reusable IP, the client-confidentiality rules that protect your license to practice, and ship a complete engagement starter kit in the capstone.
Sell More Without the Busywork
A no-code free track for salespeople. Let AI take the prospecting, research, outreach drafting, and follow-up off your plate — the desk work that sits between you and the conversations that move a number. Learn where AI fits across a deal, the deliverability and trust rules that protect your reputation, and ship a complete deal prep kit in the capstone. AI prepares; you sell.
Hand Off the Five Jobs Eating Your Evenings
A no-code free track for small-business owners. Hand off the desk work — customer replies, marketing posts, quotes and invoices, scheduling, bookkeeping prep — in the order that pays back the most, so you get back to the work you started the business to do. Learn the check-every-number and customer-data rules that keep your name safe, and ship an owner's handoff kit in the capstone. AI drafts; you decide.
Lead the Team, Not the Busywork
A free track for engineering managers, tech leads, and directors. Let AI run the back-office of leadership — meeting notes, the status layer, backlog automation, 1:1 prep, architecture-review and design-doc drafting — so your time goes to your engineers and the hard calls. Includes the people-data privacy and human-judgment rules that keep leadership human, and a capstone where you build your own leader's operating kit. AI runs the back-office; you do the leading.
What Actually Saves You Time (and What Doesn't)
A no-code track for real-estate agents. Let AI absorb the 10+ hours a week of desk work — listing copy, lead follow-up, comps summaries, client comms, marketing — so your time goes to clients, the market, and the close. Includes the Fair Housing rules (describe the property, never the buyer) and the verify-every-fact discipline that keep AI listings legal and accurate, and a capstone where you launch a full listing kit. AI drafts; you decide.
From Browser to a Real, Running Tool for Your Job
The Pro deep bridge that carries you across the no-code→code line. Set up a real local environment, read code you didn't write, debug without fear, and turn one of your own repetitive work tasks into an automated tool — all built with your own Claude. Graduate by shipping a real tool for your job and earn the AI Builder credential. The academy never runs your code; you build locally and submit proof it runs.
Author Phenomenal Skills That Remember and Evolve
The mastery sequel to Skills, Hooks & Slash Commands. Go past authoring basics to the discipline that turns a skill library into an authority moat: trigger contracts that fire proactively and refuse the adjacent wrong case, PreToolUse gates and PostToolUse verifiers that enforce quality the model cannot override, a persistent memory brain wired into your skills, the correction→rule self-evolution loop, and the sanitization gates that let you ship outward-facing skills without leaking. Ten hands-on lessons, each with a BuildChallenge you author yourself.
Design, Ship, and Run Autonomous Trading Agents — From Signal to Settlement
The production playbook for autonomous trading agents, drawn from running real perpetual-futures agents 24/7. Go from 'what is a trading agent' to operating a fleet: design the perceive-decide-act-reconcile loop, pick a venue by its liquidation math and reconciliation burden, build a signal engine that audits its own fire rate, size with fractional Kelly off available balance, place confirm-or-halt brackets with idempotent orders, keep stops on the right side of live liquidation, walk a position to profit on a conviction ladder, and wrap the whole thing in an execution-integrity layer before scaling to a supervised fleet. Ten hands-on lessons; every one ends in a BuildChallenge you implement yourself.
Mastering Generative Control on Seedance, Higgsfield & the Modern AI Camera
The craft of directing a generative video model instead of gambling on it — drawn from real, sometimes expensive, production of cinematic reels. Learn the structured timeline-prompt skeleton, the start/end-keyframe technique that lets a model fill in a journey, storyboard grids that turn one generation into a multi-shot scene, the character-bible and action-grid pipeline that locks identity before a single frame renders, the continuity and composition laws that hold a longer production together, a systematic method for diagnosing recurring generation defects, and the credit economics that separate a controlled production from a burned budget. Ten hands-on lessons; six end in a BuildChallenge you implement yourself.
Identity Systems, Continuity Engineering, and Turning a Reel Pipeline Into an Agent Fleet
The production playbook for scaling AI filmmaking past a single director working one prompt at a time. Train a Higgsfield Soul identity model for exact lookalikes, fix the real-skin-to-CGI drift that multi-hop generation chains cause, composite two independently-referenced subjects into one frame, direct twin/double characters with a locked visual law, build the world bible that keeps environments from drifting, orchestrate an entire scene-by-scene generation loop with an agent instead of authoring every prompt by hand, design in AI-disclosure compliance from the start, avoid chasing viral spectacle off your core brand, and run a real production calendar with batching and a staged-asset vault. Ten hands-on lessons; five end in a BuildChallenge you implement yourself.
Expert-Brand Strategy That Converts Attention Into Trust
The strategy layer of a working Instagram operation: build an expert brand that gets you paid for what you know instead of followed for who you are. Content quadrants, the viral fork, triple-hook carousels, distribution levers, and a DM funnel — assembled into a 30-day operating system you can run by hand before you ever automate it. Synthesizes frameworks from Devin Jatho, Brock Johnson, and heyDominik against a live production account.
Building the Agent Fleet That Runs Your Instagram Strategy For You
The system layer: turn the Instagram Growth Playbook into an agent-operated production pipeline. Build the content vault with lifecycle and near-duplicate guards, wire the quadrant gate into generation, grade drafts with an LLM judge carrying the recipe-guy guardrail, publish through GO gates with AI-disclosure compliance, run the 90/180-day upcycle queue, mine your own comments into ICP signal, and close the loop with clamped strategy mutation — then run the whole fleet for a simulated week. This is the production IP behind a live operation, componentized.
Get More Out of Every Claude Conversation
The usage-focused counterpart to building with the API — Projects and project knowledge, artifacts as a working medium, Styles and custom instructions, model selection, research/writing/analysis workflows, connectors, and a Claude-vs-ChatGPT decision framework. Ends with a personal Claude operating setup you actually keep using.
Get Dramatically More Out of the App You Already Use
The usage counterpart to building on the API: master custom instructions, memory curation, Projects, no-code custom GPTs, model choice, Deep Research, inline editing, and voice mode — then assemble it all into a personal ChatGPT operating routine. No code, no API keys, just a dramatically better daily workflow.
An Honest Framework for AI Power Users, No Code Required
For AI power users who already have opinions about their tools and want a deliberate system instead of accumulated subscriptions. Audit your real spend and usage, pick a primary assistant by an honest task-fit framework (not brand loyalty), consolidate onto the one-thinker/one-searcher/one-maker pattern, build a personal knowledge and memory layer that survives a tool swap, wire one no-code automation with a real review gate, keep a searchable saved-prompt library, run a privacy checklist that outlives any single vendor's settings, and close the loop with a recurring monthly review. Ends with the honest signal for when a no-code stack has genuinely outgrown itself.