AI Engineering & Automation

The foundation everything else builds on. You'll learn to navigate a Linux system, create and manage files, control who can access what, and chain commands together to automate tasks. By the end, you'll be able to set up users, connect to servers over SSH, install software, and run your first Docker container.

T01 Files & Navigation (+Quiz)

Learn to move around a Linux filesystem, create and organize directories, copy, move, and remove files, and search for anything on the system.

ls, cd, pwd, mkdir, rm, cp, mv, find

T02 Viewing, Editing & Permissions (+Quiz)

Read files from the terminal, edit them with nano, and control exactly who can read, write, or execute every file on the system.

cat, head, tail, less, nano, chmod, chown

T03 Pipes & Redirection (+Quiz)

Chain commands together to filter, sort, count, and search through data. Redirect output to files, combine streams, and build one-liners that do real work.

|, >, >>, 2>&1, tee, sort, uniq, wc, grep

T04 Processes & System (+Quiz)

See what's running on your system, monitor resource usage in real time, stop runaway processes, and manage background jobs.

ps, top, kill, bg, fg, jobs

Lab 1A: Server Cleanup

Put your skills to the test. You're handed a messy server with oversized log files and runaway processes. Find them, clean them up, and bring the system back to health.

Covers: filesystem audit, log cleanup, process management, disk recovery, system health

T05 Users & SSH (+Quiz)

Create and manage user accounts, configure sudo access, generate SSH keys, and connect to remote servers securely.

useradd, passwd, sudo, ssh, ssh-keygen, authorized_keys

T06 Networking (+Quiz)

Check your network interfaces, test connectivity, make HTTP requests from the terminal, understand how DNS resolves names, and identify what's listening on which ports.

ip, ss, ping, curl, DNS resolution, ports

T07 Package Management (+Quiz)

Install, update, and remove software. Manage repositories, resolve dependency issues, and keep your system current.

apt, dpkg, repositories, dependencies

T08 Docker Basics (+Quiz)

Pull images, run containers, map ports, and manage the container lifecycle. Your first step into the tool that changed how software gets deployed.

images, containers, run, ps, stop, rm, port mapping

Lab 1B: New Server Checklist

You just got access to a fresh server. Set up users, configure SSH, install essential packages, and get it production-ready from scratch.

Covers: user setup, SSH configuration, package installation, server hardening, baseline config

Exam Level 1 Master Exam

Prove you've mastered the fundamentals. 10 questions covering everything from Level 1. Score 80% or higher to pass.

Covers: files, permissions, pipes, processes, users, SSH, networking, packages, docker

Python from zero, built for AI work. Variables, data structures, file I/O, JSON, CSV, regex, error handling, HTTP requests, and CLI tool construction. Every skill you need before calling AI APIs in Level 3.

T09Variables, Types & Logic (+Quiz)

The Python you need to start: variables, types, f-strings, string methods, conditionals, loops, and functions. Every example uses server and security data from the sandbox.

variables, types, f-strings, conditionals, loops, functions

T10Data Structures (+Quiz)

Lists, dicts, sets, tuples, comprehensions, and the list-of-dicts pattern every API response uses. Each practice uses realistic data so the patterns stick.

lists, dicts, sets, tuples, comprehensions, list-of-dicts

T11File I/O & JSON (+Quiz)

Read and write files properly with the with-statement, parse JSON into Python objects, pretty-print results, and count patterns in log files.

open, with, read, write, json.load, json.dumps

T12CSV & Regex (+Quiz)

csv.reader vs DictReader, computing stats from inventory data, and the regex toolkit (search, findall, match, sub) for extracting IPs, timestamps, and error codes.

csv.reader, DictReader, re.search, re.findall, re.sub

T13Error Handling & HTTP (+Quiz)

Catch the right exceptions, call HTTP APIs with the requests library, and handle the failure modes you will see when calling AI APIs in Level 3.

try/except, requests.get, requests.post, status codes, timeouts

T14Project Setup (+Quiz)

Set up a Python project properly: environment variables for secrets, .env files, pip-managed dependencies in requirements.txt, and isolated virtual environments.

os.environ, .env, pip, requirements.txt, venv

Lab2A: Server Inventory Tool

Build a CLI that reads mixed CSV and JSON server inventory files, handles malformed data, and outputs a clean status summary.

Covers: CSV/JSON parsing, data validation, error handling, CLI output

T15CLI Tools with argparse (+Quiz)

Turn scripts into real CLI tools with shebang, chmod, argparse for arguments and flags, subcommands, auto-generated help, and proper exit codes.

shebang, chmod, argparse, subcommands, exit codes

T16Capstone: Log Analyzer (+Quiz)

Build a complete log analyzer: argparse, error handling, regex extraction, Counter aggregation, two output formats, and proper exit codes. The baseline you will upgrade with AI in Level 4.

argparse, regex, Counter, JSON/text output, exit codes

Lab2B: Log File Analyzer — No AI

Build a log parser from scratch: read auth.log, filter failures, extract attacker IPs, build a histogram, and write a structured JSON report. Pure Python, no AI.

Covers: log parsing, regex extraction, histogram, JSON report, pure Python

ExamLevel 2 Master Exam

Prove you've mastered Python for AI. 10 questions covering variables, data structures, file I/O, JSON, regex, error handling, HTTP, and CLI tools. Score 8 of 10 to pass.

Covers: variables, data structures, file I/O, JSON, regex, error handling, HTTP, CLI tools

Your first AI API calls. How tokens, context windows, and temperature work. Calling Claude, reading the response, streaming tokens. System prompts for controlling voice and format. Zero-shot, few-shot, and chain-of-thought prompting. Structured JSON output with validation. Prompt injection defense. Cost math and caching strategies.

T17Tokens, Context & Cost (+Quiz)

What a token is, how the context window works, what temperature controls, and how to calculate the cost of an API call.

tokens, context window, temperature, cost calculation

T18Your First API Call (+Quiz)

Make your first call to Claude. Read the response object: text, usage, stop_reason. Stream tokens as they arrive.

anthropic client, messages.create, response parsing, streaming

T19System Prompts (+Quiz)

Control the model's persona and format with system prompts. The same question produces different answers under different system prompts.

system role, persona control, format constraints, output shaping

T20Prompting Techniques (+Quiz)

Three prompting techniques: zero-shot for simple cases, few-shot for classification, chain of thought for multi-step reasoning.

zero-shot, few-shot, chain of thought, classification

Lab3A: Prompt Engineering Challenge

Craft prompts for five IT scenarios. Pick the right system role, format constraints, and few-shot examples for each.

Covers: system roles, format constraints, few-shot examples, scenario-specific prompting

T21Structured JSON Output (+Quiz)

Get the model to return JSON your code can parse. Schema in the system prompt, json.loads to extract data, try/except for recovery when the response is malformed.

JSON schema, json.loads, validation, error recovery

T22Temperature & Iteration (+Quiz)

Why temperature=0.0 is the right default for reliable output, why temperature=1.0 is for brainstorming, and how to iterate on prompts systematically.

temperature control, determinism, prompt iteration, A/B testing

T23Prompt Injection Defense (+Quiz)

Prompt injection: what it is, why it works, and the layered defenses that stop it. Input sanitization, output validation, token limits, and role isolation.

injection attacks, input sanitization, output validation, defense in depth

T24Cost Management (+Quiz)

Calculate per-call and monthly costs from API usage data, pick the right model tier, compress prompts to save tokens, and add response caching.

cost tracking, model selection, prompt compression, caching

Lab3B: API Wrapper Library

Build a reusable library that wraps the Anthropic API with key handling, JSON recovery, response caching, and usage logging.

Covers: API wrapping, key management, JSON recovery, caching, usage logging

ExamLevel 3 Master Exam

Prove you understand AI APIs and prompt engineering. 10 questions covering tokens, API calls, system prompts, prompting techniques, structured output, prompt safety, and cost management. Score 8 of 10 to pass.

Covers: tokens, APIs, system prompts, prompting, JSON output, injection defense, cost

Build three real AI-powered tools. A log analyzer that correlates multiple sources. A report generator that produces executive briefings and technical appendices. A ticket classifier that improves from 70% to 94% accuracy through prompt iteration. Each tool follows the same architecture: read, process, output.

T25AI Log Analyzer (+Quiz)

Build a log analyzer that replaces hand-written parsing with a single API call. argparse, error handling, and text or JSON output.

API-powered analysis, argparse, dual output formats

T26Multi-Source Correlation (+Quiz)

Analyze three log files in one pass. Concatenate sources with labels and let the model correlate IPs, reconstruct timelines, and spot patterns across files.

multi-file input, source labeling, cross-log correlation

T27Production Hardening (+Quiz)

Harden the log analyzer for production: hash-based caching, per-call logging, chunking for large files, and deduplication.

hash caching, call logging, chunking, deduplication

T28Report Generator (+Quiz)

Build a report generator with the same skeleton as the log analyzer but a different persona and output template: markdown documentation instead of analysis.

template-based prompts, markdown output, persona switching

T29Dual-Audience Reports (+Quiz)

Generate two reports from the same input: a 500-word executive briefing and a detailed technical appendix. Same data, different audiences.

audience targeting, executive vs technical, parallel generation

Lab4A: Security Alert Triage Tool

Build a triage tool that classifies 20 security alerts as true or false positive, scores confidence, and routes low-confidence cases to a human-review queue.

Covers: alert classification, confidence scoring, human-in-the-loop routing

T30Ticket Classifier (+Quiz)

Build a ticket classifier. Start with single-ticket classification, then batch 10 per call for cost savings. Measure accuracy against labeled test data.

classification, batching, accuracy measurement, test data

T31Accuracy Iteration (+Quiz)

Improve classifier accuracy from 70% to 94% in three iterations: basic prompt, few-shot examples, then confidence routing that sends uncertain tickets to a stronger model.

few-shot refinement, confidence routing, model escalation, confusion matrix

T32Tool Architecture Pattern (+Quiz)

Name the pattern. Every tool in this level follows read, process, output. Prompts live in text files, config in JSON, AI logic in a shared module.

read-process-output, prompt files, config separation, shared modules

Lab4B: Infrastructure Documentation Suite

Read five config files (nginx, sshd, docker-compose, .env, crontab), generate documentation for each, and merge them into a single wiki-ready markdown reference.

Covers: config parsing, per-file documentation, markdown merging, wiki output

ExamLevel 4 Master Exam

Prove you can build AI-powered tools. 10 questions covering the log analyzer, report generator, ticket classifier, and tool architecture patterns. Score 8 of 10 to pass.

Covers: log analyzer, report generator, ticket classifier, tool architecture

Ship the tools from Level 4 as production systems. Testing, packaging, scheduling, pipelines, batch processing, monitoring, cost optimization, and a full production capstone. The final tutorial introduces the agent pattern: observe, decide, act.

T33Testing AI Tools (+Quiz)

Four kinds of tests for AI tools: unit tests with mocked API calls, integration tests with real calls, hallucination checks, and regression tests with golden snapshots.

unittest, mocking, integration tests, golden snapshots

T34Packaging & Deployment (+Quiz)

Package tools as installable CLI commands and run them as systemd services. setup.py, pip install, systemd units, and journalctl for log inspection.

setup.py, pip install, systemd, journalctl

T35Scheduling & Monitoring (+Quiz)

Schedule tools with cron and systemd timers. Flock locking prevents overlapping runs. Three monitoring signals catch silent failures.

cron, systemd timers, flock, health checks

T36AI Pipelines (+Quiz)

Chain tools into pipelines: analyze, classify, report. Each step's output feeds the next. Conditional routing and error propagation keep the pipeline reliable.

pipeline chaining, conditional routing, error propagation

Lab5A: Production Readiness Audit

Audit a sloppy script with hardcoded keys, no error handling, no tests, and no logging. Refactor it to production standard.

Covers: security audit, error handling, test writing, logging, refactoring

T37Batch Processing (+Quiz)

Scale from 50 items to 1000+ with concurrent processing. ThreadPoolExecutor, rate limiting, progress tracking, and crash-safe resume.

ThreadPoolExecutor, rate limiting, progress bars, resume

T38Logging & Alerting (+Quiz)

Structured JSON logging on every API call plus jq aggregation. Alerts for failures, cost spikes, and accuracy drops.

JSON logging, jq aggregation, alert thresholds

T39Cost Optimization (+Quiz)

Profile costs, then optimize. Hash-based caching, prompt compression, and model routing between Haiku, Sonnet, and Opus based on task complexity.

cost profiling, caching, compression, model routing

T40Production Capstone (+Quiz)

Combine everything from this level into one production system: tested, packaged, scheduled, monitored, and cost-optimized. Run it for 24 simulated hours and verify the metrics.

full integration, 24-hour simulation, metric verification

Lab5B: Cost Optimization Challenge

Cut a $50/day AI pipeline to under $10/day without dropping accuracy below 85%. Profile first, then optimize with caching, compression, and model routing.

Covers: cost profiling, caching, prompt compression, model routing, accuracy constraints

ExamLevel 5 Master Exam

Prove you can ship AI tools to production. 10 questions covering testing, deployment, scheduling, pipelines, batch processing, monitoring, and cost optimization. Score 8 of 10 to pass.

Covers: testing, deployment, scheduling, pipelines, batch, monitoring, cost

Build an AI agent from scratch. Observe-decide-act loops, tool use with JSON dispatch, persistent memory, multi-step planning, safety guardrails, and a full 24-hour monitoring simulation. One agent.py, built piece by piece across six tutorials.

T41Your First Agent (+Quiz)

The observe-decide-act loop. Read environment state, send it to the LLM, act on the decision. The core pattern every agent system uses.

observe(), decide(), act(), event loop, LLM decisions

T42Tool Use (+Quiz)

Give the agent tools. Define JSON schemas, build a dispatch function, feed results back to the LLM for multi-step tool chains.

JSON tool schemas, dispatch dict, tool-result feedback loop

T43Memory (+Quiz)

Session memory (conversation history) and persistent memory (SQLite). The agent remembers past incidents and skips re-investigation.

message history, context trimming, SQLite, recall, store

T44Multi-Step Reasoning (+Quiz)

Plan multi-step investigations. Parse numbered plans from the LLM, execute steps in order, replan when results are unexpected.

planning prompts, step execution, replanning, memory-informed skipping

T45Guardrails (+Quiz)

Make the agent safe. Rate limiting, cost tracking, human-in-the-loop approval for dangerous actions, and audit logging everything.

rate limits, cost caps, approval gates, audit.log, graceful shutdown

Lab6A: Autonomous Log Analyzer

Build a monitoring agent against unseen events: database timeouts, memory leaks, certificate warnings. No guidance — use everything from T41-T45.

Covers: full agent, new scenarios, memory, guardrails, incident report

T46Capstone — Full Integration (+Quiz)

Run your complete agent against a 24-hour simulated incident stream. Routine logs, investigations, repeat incidents from memory, escalations, and a daily report.

24-hour simulation, all systems active, daily_report.txt

Lab6B: Agent Handoff

Your agent detects a security event it can't handle. Write a structured handoff, run a pre-built security agent, then read the resolution back into memory.

Covers: domain boundaries, handoff.json, cross-agent communication, resolution ingestion

ExamLevel 6 Master Exam

Fix a broken agent: wrong tool mappings, missing memory trimming, broken recall queries, disabled cost checks, and overwritten audit logs. 5 bugs, find and fix them all.

Covers: agent loop, tool dispatch, memory, guardrails, audit logging

Machine learning from scratch. Load data, split train/test, train your first model, evaluate with real metrics (not just accuracy), try better algorithms, learn regression, and build a full pipeline — then compare it to what Claude can do with zero training data.

T47Data and First Look (+Quiz)

Load a dataset, inspect its shape, check for missing values, understand features vs labels. The first step of every ML project.

pandas, .shape, .describe(), .info(), missing values, feature/label split

T48Train/Test Split & First Model (+Quiz)

Split data into training and test sets. Train a decision tree — your first model. Predict on test data and see how it does.

train_test_split, DecisionTreeClassifier, .fit(), .predict()

T49Evaluation Metrics (+Quiz)

Why accuracy lies. Precision, recall, F1, and confusion matrices — the metrics that actually tell you if your model works.

accuracy, precision, recall, F1, confusion matrix, classification_report

T50Better Models (+Quiz)

Random forests, gradient boosting, and cross-validation. Try multiple algorithms and pick the one that actually performs best.

RandomForest, GradientBoosting, cross_val_score, model comparison

Lab7A: Incident Classifier

Build a classifier that categorizes security incidents by severity. Train, evaluate, and improve until F1 exceeds 0.85.

Covers: data prep, model training, evaluation, iteration, threshold tuning

T51Regression (+Quiz)

Predict continuous values instead of categories. Linear regression, feature scaling, and regression-specific metrics (MSE, R², MAE).

LinearRegression, StandardScaler, MSE, R², MAE

T52Full Pipeline & Claude Comparison (+Quiz)

Build a complete ML pipeline, then give Claude the same data with zero training. Compare accuracy, speed, and cost. Learn when each approach wins.

Pipeline, end-to-end ML, LLM vs ML comparison, trade-off analysis

Lab7B: Model Autopsy

A model is making bad predictions. Diagnose it: check the data, inspect feature importances, find the bias, retrain, and document what went wrong.

Covers: debugging ML, feature importance, data inspection, bias detection, retraining

ExamLevel 7 Master Exam

Prove you understand ML fundamentals. Train/test splits, evaluation metrics, model selection, regression, and when to use ML vs LLMs. Score 8 of 10 to pass.

Covers: data prep, train/test, metrics, model comparison, regression, ML vs LLM

How neural networks actually work. Tensors, layers, activation functions, the training loop. Build a network from scratch, use pre-trained models, fine-tune via API, and learn when fine-tuning beats prompting.

T53Neural Networks & Tensors (+Quiz)

What a neural network is, what tensors are, how layers transform data. The conceptual foundation before writing code.

tensors, layers, activation functions, forward pass, shapes

T54Building a Network (+Quiz)

Build a neural network in code. Define layers, pick an optimizer, and wire it together into something that can learn.

Sequential model, Dense layers, optimizer, loss function

T55The Training Loop (+Quiz)

Train the network: forward pass, loss calculation, backpropagation, weight update. Watch the loss decrease over epochs.

epochs, batches, loss curves, overfitting, validation

Lab8A: Training Diagnostics

A network is overfitting badly. Diagnose it from the loss curves, apply fixes (dropout, early stopping, more data), and retrain until it generalizes.

Covers: loss curves, overfitting diagnosis, dropout, early stopping, regularization

T56Pre-trained Models (+Quiz)

Use models someone else already trained. Load pre-trained weights, run inference, and understand transfer learning.

pre-trained weights, transfer learning, inference, model zoo

T57Fine-Tuning via API (+Quiz)

Fine-tune an LLM through an API. Prepare training data, submit a fine-tuning job, evaluate the result, and compare to prompt engineering.

training data format, fine-tuning API, evaluation, prompt vs fine-tune

T58The Decision Framework (+Quiz)

When to prompt, when to fine-tune, when to train from scratch. A decision tree based on data size, task type, cost, and latency requirements.

decision framework, cost analysis, latency trade-offs, build vs buy

Lab8B: Choose the Right Model

Three tasks, three approaches: prompting, fine-tuning, and training from scratch. Pick the right one for each, justify your choice, and prove it with metrics.

Covers: approach selection, justification, metric comparison, cost analysis

ExamLevel 8 Master Exam

Prove you understand neural networks and fine-tuning. Tensors, training loops, overfitting, pre-trained models, fine-tuning vs prompting. Score 8 of 10 to pass.

Covers: tensors, networks, training, pre-trained models, fine-tuning, decision framework

Ship models to production. Save and load trained models, serve predictions via Flask, batch processing, prediction logging, drift detection, automated retraining, and full integration. The engineering that turns a notebook into a service.

T59Save & Load Models (+Quiz)

Serialize trained models to disk with joblib/pickle. Load them in a fresh process. Version your models so you can roll back.

joblib.dump, joblib.load, model versioning, artifact management

T60Flask Predict Endpoint (+Quiz)

Wrap your model in a Flask API. Accept JSON input, run inference, return predictions. The standard pattern for serving ML models.

Flask, @app.route, request.json, jsonify, model serving

T61Batch Prediction (+Quiz)

Process thousands of predictions efficiently. Read from CSV, predict in batches, write results. Handle failures without losing completed work.

batch processing, CSV I/O, checkpointing, error recovery

T62Prediction Logging (+Quiz)

Log every prediction: input, output, confidence, latency, timestamp. Build the audit trail you need to debug production issues.

structured logging, prediction audit trail, latency tracking

Lab9A: Log Analysis

Analyze 10,000 prediction logs. Find the slow predictions, the low-confidence ones, and the patterns that indicate something is wrong.

Covers: log analysis, anomaly detection, performance profiling, reporting

T63Drift Detection (+Quiz)

Models decay. Detect when your input data or prediction accuracy drifts from what the model was trained on. Statistical tests and threshold alerts.

data drift, concept drift, statistical tests, monitoring thresholds

T64Retraining Pipeline (+Quiz)

Automate retraining. When drift is detected, pull fresh data, retrain, evaluate against the current model, and swap if the new one wins.

automated retraining, A/B model comparison, model swapping, rollback

T65Full Integration (+Quiz)

Wire everything together: model serving, batch processing, logging, drift detection, and retraining in one integrated system.

end-to-end MLOps, full pipeline, production integration

Lab9B: Production Incident

Your model is returning bad predictions in production. Diagnose from logs, detect drift, retrain, validate, and deploy the fix. Full incident response.

Covers: incident response, drift diagnosis, emergency retraining, validation, deployment

ExamLevel 9 Master Exam

Prove you can run ML in production. Model serving, batch processing, logging, drift detection, retraining pipelines, and incident response. Score 8 of 10 to pass.

Covers: model serving, batch, logging, drift, retraining, incident response

Capstone projects that combine everything from Levels 1-9. Build a cross-host security analyzer, a self-healing infrastructure agent, an incident correlation engine, and a production-grade deployment of your best tool.

LabA: Automated Security Report Generator

Pull 24-hour auth logs from three servers, run AI analysis on each, correlate findings across hosts, and produce both an executive briefing and a technical appendix.

Covers: multi-host collection, AI analysis, cross-host correlation, dual-audience reporting

LabB: Self-Healing Infrastructure Agent

Build the agent loop: watch system state, decide what to do, execute whitelisted tools, escalate when uncertain, and audit-log every action.

Covers: agent loop, system monitoring, tool execution, escalation, audit logging

LabC: Incident Correlation Engine

Three monitoring tools fired alerts in the same hour. Build an engine that ingests events, groups them into incidents, and separates coincidence from genuine correlation.

Covers: event ingestion, incident grouping, correlation scoring, false positive filtering

LabD: Full-Stack Tool Deployment

Take your best tool from the course and ship it production-grade with caching, tests, logging, cost tracking, and a systemd service. Run it for 24 simulated hours and verify the metrics.

Covers: full deployment, caching, testing, logging, cost tracking, 24-hour verification

AI Engineering & Automation

Full Curriculum

Where these skills take you

Start building AI skills