The Curriculum That Closes the Gap Between Knowing About AI and Running It.

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 communicating with AI — write prompts that get results, build system prompts that shape behavior, and master the techniques that separate operators from novices.

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 — master Gemini 2.0 Flash, Pro, and Ultra, harness the 1M token context window, process images/audio/video natively, and build production pipelines with the Gemini API.

From prompt to pixel — master AI image generation across every major platform, build production fallback chains, and learn the craft of visual prompting that separates operators from amateurs.

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.

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.

Build the mental model that separates operators from casual users. Understand AI as an operating system — persistent, routed, and compounding.

Set up the persistent agent platform, MCP servers, memory layer, watchdogs, and the full service architecture that runs 24/7.

Build content flywheels, cron-AI pipelines, model routing, and git-based deployment — systems that produce output while you sleep.

The operational rules that prevent catastrophic failure: stop-and-replan, E2E validation, compound learning, security, cost discipline, and ticket hygiene.

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.

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.

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 that separates power users from everyone else — hidden settings, hook architecture, model routing, subagent configuration, agent teams, and fleet deployment across machines.

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 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.

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 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.

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.

Component weighting, fire-rate monitoring, ceiling analysis, arithmetic backtesting, and the math that prevents dead components from silently killing your signal. Drawn from the Hermes score rebalancing that took a bot from 2,646 signals and zero trades to live in one session.

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.

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 Hermes calibrator problem in 60 seconds of SQL.

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 Hermes PR #28 delegation that took a scoring rebalance from concept to merged PR with zero back-and-forth.

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.

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.

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 without babysitting — validation agents, swarms with consensus, code review agents, confidence scoring, escalation protocols, and kill switches. Trust is earned, not assumed.

Competitive intelligence as modern prophecy — build AI-powered systems that monitor markets, extract signals from noise, track competitor moves, and synthesize intelligence into decisions.

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.

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.

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.

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.

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.

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.

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.