The engineer's path to production-grade AI systems for the cybersecurity-AI stack.

• Lesson 1.1, Neural networks from scratch (Karpathy's micrograd)Free preview35 min
• Lesson 1.2, The makemore series: building character-level language modelsFree preview40 min
• Lesson 1.3, The transformer architecture explained: attention, MLPs, residual streams, layer norm50 min
• Lesson 1.4, Building a small GPT from scratch (Karpathy's Let's build GPT)60 min
• Lesson 1.5, Tokenization deep look (BPE, WordPiece, SentencePiece)35 min
• Lesson 1.6, Why scale works: emergence, capabilities, the bitter lesson30 min

• Lesson 2.1, The scaling laws: why bigger works, and the limits of that36 min
• Lesson 2.2, Closed-weight frontier models: GPT-4o, Claude 3 family, Gemini 2.038 min
• Lesson 2.3, Open-weight models: Llama 3, Mistral, Command R+, and when to self-host34 min
• Lesson 2.4, Benchmark literacy: what the numbers mean and what they hide30 min
• Lesson 2.5, Model selection in practice: a decision framework for production systems32 min

• Lesson 3.1, How prompts work: tokens, context, and the generation process30 min
• Lesson 3.2, System prompts, personas, and instruction design36 min
• Lesson 3.3, Chain-of-thought prompting: the Wei et al. paper and its production implications34 min
• Lesson 3.4, Structured outputs: JSON, function calling, and schema enforcement36 min
• Lesson 3.5, Few-shot prompting and example selection28 min
• Lesson 3.6, Prompt evaluation, regression testing, and failure analysis34 min

• Lesson 4.1, What RAG actually is: the Lewis et al. paper and why retrieval changes everything32 min
• Lesson 4.2, Chunking strategy: the decision that determines everything downstream38 min
• Lesson 4.3, Embedding models: selection, benchmarking, and the MTEB leaderboard35 min
• Lesson 4.4, Vector databases in production: indexing, scaling, and operational realities40 min
• Lesson 4.5, Hybrid search, re-ranking, and query understanding42 min
• Lesson 4.6, Prompt construction for RAG: context assembly and faithfulness36 min
• Lesson 4.7, Evaluating RAG systems: the Hamel Husain eval-driven approach44 min

• Lesson 5.1, The fine-tuning decision: when it beats prompting and RAG, when it does not35 min
• Lesson 5.2, What fine-tuning does to model weights: SFT, catastrophic forgetting, and the ULMFiT insight38 min
• Lesson 5.3, LoRA and QLoRA: efficient fine-tuning without full parameter updates42 min
• Lesson 5.4, Data preparation: the part that determines everything40 min
• Lesson 5.5, Running a fine-tuning job: infrastructure, hyperparameters, and the training loop44 min

• Lesson 6.1, What agents actually are: the ReAct loop, planning, memory, and action42 min
• Lesson 6.2, Tool use in practice: defining tools, structured outputs, and the Instructor pattern45 min
• Lesson 6.3, Agent architectures: single-agent, multi-agent, hierarchical, and swarm patterns44 min
• Lesson 6.4, Memory systems for agents: in-context, external, procedural, and episodic38 min
• Lesson 6.5, Error handling and recovery loops: how production agents survive failures40 min
• Lesson 6.6, Cost and latency control for agents: governors, caching, and early stopping36 min
• Lesson 6.7, Agent evaluation: what to measure and how to measure it40 min

• Lesson 7.1, Why evals are a first-class engineering discipline (Husain, Yan, Huyen)38 min
• Lesson 7.2, Building your golden dataset: task design and ground truth labeling42 min
• Lesson 7.3, Offline eval methods: deterministic checks, LLM-as-judge, and rubric design48 min
• Lesson 7.4, Online evaluation: A/B testing AI systems in production40 min
• Lesson 7.5, Human review: when automated evals are not enough36 min
• Lesson 7.6, Regression detection and the continuous eval pipeline44 min

• Lesson 8.1, Why AI systems fail in production and what signals catch them44 min
• Lesson 8.2, Structured logging for LLM calls: what to capture and why48 min
• Lesson 8.3, Distributed tracing for AI systems with OpenTelemetry46 min
• Lesson 8.4, Metrics, dashboards, and SLOs for AI systems42 min
• Lesson 8.5, Incident response and operational runbooks for AI systems40 min

• Lesson 9.1, The economics of inference: tokens, throughput, and the cost model40 min
• Lesson 9.2, Prompt caching and prefix reuse: the fastest cost reduction available44 min
• Lesson 9.3, Model selection, routing, and right-sizing46 min
• Lesson 9.4, Context compression, output length control, and prompt efficiency44 min
• Lesson 9.5, Inference optimization: batching, quantization, and self-hosting tradeoffs48 min

• Lesson 10.1, The AI safety picture: what engineers need to know45 min
• Lesson 10.2, Prompt injection and jailbreak attacks: the threat model50 min
• Lesson 10.3, Input filters and content classifiers50 min
• Lesson 10.4, Output validation and structured output enforcement45 min
• Lesson 10.5, Sandboxing, monitoring, and the safety review process50 min

• Lesson 11.1, How embedding models work: from word2vec to modern dense retrievers45 min
• Lesson 11.2, Choosing and evaluating embedding models for your use case40 min
• Lesson 11.3, Vector databases at production scale: ANN algorithms and tradeoffs50 min
• Lesson 11.4, Hybrid search, re-ranking, and the production retrieval pipeline45 min

• Lesson 12.1, How multi-modal models work: image tokens, patches, and cross-modal attention42 min
• Lesson 12.2, Vision APIs in production: Claude, GPT-4V, Gemini (input formats, costs, tradeoffs)38 min
• Lesson 12.3, Document intelligence: OCR, PDF extraction, structured data from complex layouts44 min
• Lesson 12.4, Multi-modal RAG: embedding images and documents, cross-modal retrieval46 min
• Lesson 12.5, Audio AI engineering: Whisper, TTS, voice application patterns36 min

• Lesson 13.1, Model serving architectures: KServe, Ray Serve, BentoML, Modal, managed APIs44 min
• Lesson 13.2, Deployment patterns: blue/green, canary, shadow, feature flags40 min
• Lesson 13.3, A/B routing: model version experiments and traffic splitting38 min
• Lesson 13.4, Observability for AI inference: traces, metrics, latency, and model-specific signals42 min
• Lesson 13.5, Cost guardrails: rate limiting, spend caps, and circuit breakers36 min

• Lesson 14.1, The security AI picture: what's real, what's hype, what engineers build45 min
• Lesson 14.2, LLMs for log analysis and alert triage55 min
• Lesson 14.3, AI-assisted code security review: SAST integration and LLM augmentation50 min
• Lesson 14.4, Threat intelligence enrichment with AI45 min
• Lesson 14.5, Adversarial AI: when your security AI is the target45 min

• Lesson 15.1, The frontier lab hiring bar: what these organizations actually evaluate40 min
• Lesson 15.2, ML systems design interviews: framework and practice55 min
• Lesson 15.3, Coding interviews for AI engineers: patterns and preparation50 min
• Lesson 15.4, Take-home projects: how to approach, execute, and present45 min
• Lesson 15.5, Behavioral interviews for AI engineering roles40 min

• Lesson 16.1, The startup AI stack: what to build, what to buy, what to skip45 min
• Lesson 16.2, Model selection under cost and latency constraints42 min
• Lesson 16.3, Eval strategy at startup speed vs. scale rigor40 min
• Lesson 16.4, Scaling the AI system: what breaks and in what order43 min

• Lesson 17.1, How the best AI engineers stay current: real systems and rhythms38 min
• Lesson 17.2, Reading research: how to extract engineering signal from papers35 min
• Lesson 17.3, The field's evolution: what has changed, what is changing, and how to anticipate what comes next42 min

• Capstone Rubric, AI Engineering Mastery15 min

Module 2 covers the frontier models and is updated quarterly as major model releases ship. The course teaches model-agnostic patterns (RAG, eval, agents, observability) that work regardless of which frontier model you use. When a new model changes best practices, the affected module gets a versioned update with a changelog note.

Both. Production reference repositories ship with every hands-on module: a fully working RAG pipeline for Module 4, an agent scaffold for Module 6, an eval harness for Module 7, a cost-optimization case study codebase for Module 9. You also write code from scratch in Module 1 (building a transformer in PyTorch from neurons up). Every repo is on GitHub with a documented setup.

No GPU is required for the course itself. All lesson code runs on CPU or free-tier Colab. The capstone uses cloud inference APIs (OpenAI, Anthropic, or an open model via Replicate or Modal). Budget $20 to $50 in cloud credits for the capstone project. The course covers cost-optimization techniques that keep that number low.

Self-paced. The course is 70 to 90 hours of structured learning across 18 modules. Most practitioners finish the modules over 12 to 16 weeks at 5 to 7 hours per week, then spend an additional 4 to 6 weeks on the capstone. The capstone is a production system, not a checklist, so time varies by project scope.

Required: intermediate Python (you can write functions, work with libraries, read unfamiliar code), comfort reading research code, and basic ML fundamentals (gradient descent, neural network forward pass, training and eval loop). Recommended: prior production engineering experience, baseline familiarity with at least one transformer library (Hugging Face, PyTorch), and prior exposure to a vector database or LLM API.

This course cites and builds on all three. Karpathy's YouTube teaches neural network fundamentals with exceptional clarity. fast.ai teaches top-down practical deep learning. DeepLearning.AI covers the full ML stack. None of them focus on production AI engineering: RAG at scale, eval harnesses, agent reliability, cost optimization, observability, and the cybersecurity-AI convergence layer. This course integrates those foundations and adds the production and security engineering depth practitioners need on the job.

Module 15 covers frontier lab interview preparation directly: Anthropic, OpenAI, and Google DeepMind interview patterns across ML systems design, coding, take-home, and behavioral rounds. The capstone produces a public artifact (working system, case study, demo) that interviewers can evaluate. The verifiable Ed25519 credential is linked from your LinkedIn profile. The combination of demonstrated work plus structured interview preparation is what matters, not the credential alone.

Seven-day full refund from purchase, while you have completed less than 10% of the course. Email support@decipheru.com with your order number; refunds process within 3 business days. After 7 days or above 10% completion, refunds are case-by-case. A refund triggers a 90-day lockout on re-purchasing this course or subscribing to a tier that bundles it.

Approved capstones earn the AI Engineering Mastery verifiable credential, signed with Ed25519 and embeddable on LinkedIn. The credential links to a public verification URL. It is renewable through one continuing-practice exercise per year to reflect the field's pace. Issued by DecipherU. It is a course-completion credential, not an accredited degree or a vendor-issued certification.

Module 1 starts from neurons and builds up to a transformer from scratch. If you can follow Karpathy's micrograd tutorial on YouTube and write basic Python functions, you have the baseline for Module 1. For practitioners who want a prerequisite bridge, the course includes a recommended reading list covering Python fundamentals, linear algebra intuition, and basic ML concepts before Module 1.