A 12-minute orientation to the Advanced Evals skill path — judges, suites, and gates: the three layers that turn eval-by-vibes into a discipline that ships

Stop checking outputs by vibes — build a runnable eval with a golden dataset, deterministic scorer, and LLM judge, and read the result like an engineer

Design judges that survive CALM biases, calibrate against humans, and earn a place in your CI gate

Author, run, and visualize frontier-grade eval suites with UK AISI's open-source framework

Wire per-PR evals into GitHub Actions, pick thresholds that survive flakiness, and decide when a gate belongs on main

Orientation across the four-chapter Adversarial AI skill path — defender → threat-surface → offense → program — covering everything from your first prompt-injection patch to running an internal red-team practice

Why prompt injection exists, how attackers exploit it, and the layered defense every LLM-powered feature needs before shipping

Map and defend the agent-era attack surface — RAG poisoning, document-borne payloads, memory poisoning, and tool-output hijacking that direct-injection defenses don't reach

Stand up automated offensive tooling for AI red-teaming — DeepTeam, PyRIT, Mindgard; attacker LRMs and BYO-attacker pattern; PAIR, TAP, GCG algorithms; and trajectory caching that turns expensive discovery into cheap CI gates

Run a red-team program for production AI — taxonomy, the finding lifecycle, runtime monitoring, alignment regression, and the internal playbook

A 12-minute orientation to the Agent Engineering skill path — primitives for tool use, memory, skills, retrieval, and failure recovery

Build the smallest possible agent — one model, one tool, one memory slot — and see exactly what makes the loop tick

Tool use, ReAct loops, multi-agent orchestration, and guardrails for reliable agent systems

Design memory systems that give AI agents continuity across sessions

Connect Claude to your tools using the Model Context Protocol

Master the art and science of building Agent Skills — reusable instruction packages that teach AI agents your workflows

Build agents that plan, retrieve, self-correct, and route across knowledge sources

Build agents that survive tool failures, runaway loops, and cascading errors — with retry, circuit breakers, and human escalation

A 12-minute orientation to the Agent Infrastructure skill path — the substrate beneath production agents and the two protocols you have to get right

Build agents that talk to other agents — A2A, signed agent cards, secure delegation, and multi-framework bridges

Pick the right isolation primitive — E2B, Modal, or Daytona — for agents that run untrusted code

A 12-minute orientation to the Agent Frameworks skill path — what each chapter teaches, how they relate, and where to start

Navigate the API-to-agent stack across OpenAI and Anthropic — understand the layers before you build

Master both the Responses API and Chat Completions — understand when to use each and how to migrate

Master the Messages API, tool use, extended thinking, and prompt caching — build with Claude from first principles

Build multi-agent systems with guardrails, handoffs, and tracing — OpenAI's framework for autonomous AI

Build autonomous agents with Anthropic's framework — the same engine that powers Claude Code, as a library you control

Ship multi-agent systems that integrate with real tools, scale in containers, and verify their own work

Mock tools, trace decisions, build golden datasets, and run agent tests in CI/CD — testing for non-deterministic AI systems

Read, debug, and ship across LangGraph, CrewAI, and AutoGen — the three frameworks you'll meet in customer code

Orient through the chapter — name the four artifact families a non-coder can build with AI (custom assistants, single-file artifacts, full prototypes, end-to-end coding-agent workflows), see the skill-path map of the six chapters and how they relate, recognize the concrete capabilities at chapter end, and pick the recommended starting path (CLI-comfortable: 5.1.2; no-CLI starter: 5.1.3)

Get Claude Code on your Mac, learn how to brief it, give it a project memory with CLAUDE.md, capture repeated work as Skills, run a hands-on first project, and keep token spend honest — explained without jargon for non-coders

Understand AI agents from the ground up — distinguish them from chatbots and Claude Code, learn the agent loop, see how tools turn thinking into doing, recognize when an agent is the right shape, and have Claude Code build your first customer-research agent end-to-end

Stop re-pasting context every chat — package your prompts, files, and tone as reusable assistants on ChatGPT (Custom GPTs), Claude (Projects + Skills), and Gemini (Gems), with the four levers, sharing patterns, and when a saved prompt would do better

From a messy CSV to a single-file HTML dashboard you can email — paste data, brief the dashboard, iterate without breaking sections, share, and recognize where this approach fits (single-stakeholder snapshots) vs where it does not (live data, multi-user, regulated)

From a small-tool idea to a clickable demo at a URL — pick the right design-first surface (Lovable for working app, Claude Design for polished + hand-off-ready), brief in experience-language not implementation, iterate without breaking the prototype, and recognize the 80% wall that signals time to hand off to Claude Code for real implementation

Recognize the five predictable failure modes when AI coding agents stop cooperating (loop, context overflow, silent regression, phantom imports, configuration drift), apply the matching recovery move (interrupt, redirect, restart), and know when to escalate to a real developer instead of pushing the agent further

The map of the AI Engineering Foundations skill path — what each chapter teaches, how they fit together, and where to start

Write prompts that work like programs — structured, testable, and consistently effective

Master the art and science of curating optimal context for AI agents

Constrained decoding, schema engineering, and type-safe AI pipelines

Build the minimum viable RAG pipeline — chunk, embed, store, retrieve, augment, generate — in plain code

Take the retrieval backbone to production — embeddings, chunking strategies, hybrid retrieval, advanced patterns, and evaluation. Assumes RAG Foundations.

When to fine-tune vs RAG vs prompting — SFT, LoRA, dataset prep, and evaluation

Vision, document, PDF, and video processing — build with images and audio, not just text

Build high-quality training and eval datasets — synthetic data, labeling, and curation pipelines

Prompt caching, KV-cache, batching, speculative decoding, and token budgeting

Architect knowledge bases that AI agents can navigate, retrieve from, and act upon

Pick the right post-training algorithm — DPO, GRPO, Dr-GRPO, DAPO, KTO, GiGPO — without drowning in research papers

A 12-minute orientation to the AI Governance & Compliance skill path — the rules, the evidence, and the response that turn "we should be compliant" into a program regulators accept

Ship compliant general-purpose AI before 2 Aug 2026 — scope, tech docs, copyright, systemic risk, and the Code of Practice shortcut

Produce audit-ready model cards and signed, immutable logs that tie every output to its source, model version, and policy

Handle the 3am page — detect AI failures, contain blast radius, file Article 62 reports on time, and turn post-mortems into hardening

Navigate the fragmented US AI regulatory landscape — NIST AI RMF, state-level laws, post-EO federal posture, and enforcement actions that set precedent

Map the compliance terrain beyond the EU and US — UK AISI, OECD AI Principles, ISO/IEC 42001 certification, and the frameworks shaping AI governance worldwide

Comply with sector regulators — HIPAA for healthcare AI, FDA for medical devices, FINRA for financial services, and PCI-DSS for payment systems

A short orientation — what this practicum is, what you bring to it, and where to start

The contract, the prerequisites, and the real problem you will carry through all seven chapters — from customer evidence to a shipped, measured outcome

Working business literacy for engineers — what your last feature actually cost, unit economics on a napkin, and the one metric your team moves

Discovery for engineers — how to run a 30-minute call that surfaces real problems, not polite opinions

The spec is your primary artifact now — one page, checkable criteria, and a two-run diff test that turns every divergence into a fix before it reaches a session

Delegation patterns, parallel sessions without chaos, and the verification gates war stories teach — built into one runbook that compounds with every failure

What to keep doing by hand, on purpose. Deliberate practice on genuinely hard problems and the weekly habit that keeps your Learning Velocity from quietly degrading

Define done in business terms, instrument before the work lands, and write the outcome in two paragraphs a CFO would read — then do it on your own project

A 12-minute orientation to the Code Testing skill path — the five feedback layers that keep Claude Code and Codex honest, and the order to learn them in

Test strategy, the testing trophy, and writing automated tests that actually catch bugs

Wire Ruff, Biome, Pyrefly, ty, Semgrep, and CodeQL as sub-second feedback sources for Claude Code and Codex

Wire format, lint, type-check, and test into a layered hook stack that forces Claude Code and Codex to fix before they commit

The two-tool feedback loop — coverage shows where tests are missing, mutation shows whether the tests you have actually catch bugs

From one-shot prompts to feedback-driven loops — drive, supervise, and review the systems that now write your tests

Move past hand-picked examples — specify invariants, let generators hunt counterexamples, and pair the discipline with agents that propose the properties you missed

Orientation to the Coding Agent Craft skill path — the cross-vendor patterns that make any coding agent reliable, and where to start based on your current pain

Architect your codebase and workflow for maximum AI collaboration

Advanced git techniques for AI engineers — worktrees, bisect, reflog — each with agent workflows

Make one file work across Claude Code, Codex, Gemini CLI, Cursor, and Copilot — the cross-vendor spec, hierarchy, and migration audit for agent-native repositories

Honest, benchmark-cited decision guide for picking — and switching between — the three terminal coding agents reshaping dev work in 2026

Make the spec your source of truth — run the Spec Kit pipeline across Claude Code, Codex, and Gemini CLI and regenerate code from evolving specs

Frame bugs, read errors, bisect regressions, and find root causes fast — with any coding agent as your debugging partner

Coordinate multiple coding-agent sessions as peers — shared tasks, mailboxes, and the decision tree for picking teams vs subagents vs parallel sessions

Wire any coding agent into CI/CD and ops — automated pipelines, scheduled jobs, and business workflows end-to-end

Roll out coding agents across a team — pilot to org, SSO patterns, cost governance, shared conventions, sandboxing, and enterprise graduation. Cross-vendor.

A 12-minute orientation to five coding agents whose feature lists have converged near 1M context — so the real decision is fit, not capability.

Anthropic's terminal-native coding agent — architecture, 1M-token context, permissions, cost model, and honest trade-offs for engineering managers evaluating their options.

OpenAI's async-first coding agent — CLI and cloud task architecture, sandboxed execution, permissions model, cost structure, and honest trade-offs for engineering managers evaluating their options.

Google's open-source terminal agent — being sunset for consumer, Pro, and Ultra users on 18 June 2026 in favor of the closed-source Antigravity CLI.

Microsoft/GitHub's IDE-native coding assistant ecosystem — surfaces, architecture, context handling, permissions, cost model, and honest trade-offs for engineering managers evaluating their options.

The AI-native IDE that forks VS Code and weaves multiple models into every editing surface — architecture, context handling, permissions, cost model, and honest trade-offs for engineering managers evaluating their options.

A decision framework for engineering managers evaluating coding agents — dimensions that matter, team archetypes, multi-agent strategies, and rollout playbook.

A decision guide to the two dominant deep learning frameworks — their philosophies, ecosystems, and the practical factors that should drive your choice.

The first strategic decision after choosing deep learning: train a new network from zero or stand on the shoulders of pretrained giants.

A decision framework for choosing between Deep Learning and classical Machine Learning — based on your data, compute, timeline, and interpretability needs.

A 12-minute orientation to the Deep Learning skill path — why it exists, what you will build, how the six chapters connect, and where to begin.

Image classification, object detection, and segmentation — pick the right computer vision task before you pick an architecture.

The full toolkit for training neural networks — batch size, learning rates, loss functions, activations, optimizers, regularization, and early stopping.

Design, train, and interpret the architecture that powers modern computer vision — from first convolution to production deployment.

A short orientation — what this path covers, who it's for, and where to begin

The market stopped paying a premium for the old job. This chapter names the new contract, maps eight durable skills to it, and ends with the honest self-score that anchors your 90-day plan

A practitioner montage of what agents absorbed, what they didn't, and how to audit your own week to find out where your work actually lives now

Ninety percent of your old skills just went to zero, and the leverage on the remaining ten percent multiplied — depth becomes the license to delegate

The PM craft that lands on your desk when nothing arrives pre-chewed: appetite, problem statements, the no-list, and the one-pager that gets a decision made

When the agent returns ten working versions before lunch, selecting the right one is the job — and the trained eye that does it is learnable, on a schedule

Reviewing work you didn't write, at volume — the traps green tests hide, when to throw away instead of steer, and the practice that keeps the catching skill alive

Turn six chapters of work into one closing page: a builder-shaped job description, one booked customer conversation, and a 90-day plan around your weakest two durable skills with a manager script

A 12-minute orientation to the E2E & Multimodal Testing skill path — the four senses QA needs when agents ship multimodal products, and the order to learn them in

Master browser testing with Playwright — locators, assertions, debugging, and cross-browser automation

AI agents that browse, click, and test — Playwright MCP, Test Agents, and autonomous QA workflows

Screenshots meet LLM vision — semantic visual QA, vibe checks, design fidelity, and intelligent visual regression

Test what users hear — voice bot QA, audio quality analysis, speech pipeline testing, and multimodal CI

CI/CD pipelines, sharding, test observability, and AI-powered orchestration for production-grade testing

The map of this path — why running models locally is worth it, how the six chapters build on each other, and where to begin.

The model on your own machine is weaker than the frontier — and that trade is worth making more often than you'd think.

Four friendly front doors, one shared engine underneath — so the choice is about comfort, not capability.

One number decides whether a model runs on your machine — and one trick lets you bend it.

Your hardware already narrowed the field — now choose by the job and read the license before you commit.

Local models speak the same language as the cloud — so wiring one into your code is mostly changing a single line.

Outgrew your hardware? The upgrade is one number — grow the right kind of memory, and a whole model class opens up.

Learn why a three-way split is non-negotiable, how to choose ratios, preserve structure, respect time, and prevent the leakage that makes models look great in notebooks but fail in production.

Learn the systematic process for choosing the right ML algorithm: baseline first, match to data characteristics, validate with cross-validation, and know when to ship.

The orientation map for the Machine Learning path — why these six chapters live together, what you will be able to do after completing them, and where to begin.

Map each ML problem type to the concrete algorithm families in scikit-learn — linear models, trees, SVMs, ensembles, and more — so you pick the right tool before you write a line of code.

Missing values, outliers, scaling, encoding, and pipeline assembly — turn raw EDA findings into model-ready features.

Master the systematic investigation of datasets before modeling — distributions reveal shape, correlations reveal signal, and anomalies reveal what needs fixing.

Learn to identify whether your business question demands a classifier, a regressor, or a clustering algorithm — the decision that shapes every downstream choice.

A 12-minute orientation to the On-Device & Edge AI skill path — the three platforms where your model can run without a cloud round-trip, and how to pick yours

Ship a capable ~3B LLM inside your iOS app — guided generation, tool calling, and when to still reach for Claude

Ship on-device AI to 140M+ Android devices — AICore as a shared system service, ML Kit GenAI APIs, and Gemma 4 agentic intelligence

Run arbitrary open models on your Mac — unified memory, JANG quantization, Ollama + MLX, and the honest limits of a single-user inference node

The map of the Production AI skill path — what each chapter teaches, how they fit together, and where to start

Build eval suites, catch regressions, and ship AI features with confidence

Deploy, monitor, and operate AI systems that stay reliable at scale

Instrument, debug, and optimize multi-step AI agents in production

Protect AI applications — from prompt injection defense to EU AI Act compliance

Master token economics, model routing, and budget governance to run AI sustainably

SSE, WebSockets, partial JSON parsing, streaming tool calls, and responsive AI interfaces

Architect reliable, scalable AI-native applications for production

Design AI features users actually trust — confidence indicators, graceful failures, and human-in-the-loop

Prepare for model deprecations, build abstraction layers, and route across providers with confidence

Why k6 and Locust lie about streaming LLMs — TTFT, ITL, goodput, GPU saturation, and SLO-gated load tests that actually predict production

A 12-minute orientation to the Specialized Agents skill path — four agent archetypes, when to pick each, and what makes them fail

Master the plan-execute-synthesize archetype behind ChatGPT, Gemini, Perplexity, and Claude deep research — and know when not to use it

Build AI agents that see, click, and control desktop environments

Real-time voice agents — streaming audio, turn-taking, telephony, and emotion-aware delivery

Architect always-on agents that run on cron schedules, fire on webhooks, and execute autonomously with human gates