Build network automation faster with AI. Keep the judgment.

Course map

From first prompt to governed agent

1. 0. Start Here

   1 lesson

   A guided tour of how the course works, taken before you touch a device. It shows you the tools the course uses, explains the vocabulary and typography conventions you will see in every lesson, describes what the terminal casts are for and how to use them well, walks through how the graded labs, Try-it blocks, and knowledge checks work, and explains how the AI sections run on an assistant you bring, with grading that never requires one. The tour takes about fifteen minutes.

2. 1. Just Enough Python

   5 lessons

   Exactly the Python the rest of this course uses, and nothing more: strings and f-strings, lists and dicts and their nesting, loops and decisions, functions that return values, and how to read a failed check as a to-do item, all taught on network data. It opens with a fifteen-minute placement check: pass it and you skip straight to The Day-One Loop with a clear conscience. The free Python Foundations course remains the deeper dive; nothing here requires it.

3. 2. The Day-One Automation Loop

   3 lessons

   The full loop on a simulated network in your browser: discover and document from one IP, push config from data and prove it landed, and validate a change before and after. You inspect the recorded tool run, open the hood, and own a graded piece each lesson. No hardware, fully deterministic.

4. 3. Be the Human in the Loop: Read, Run, and Judge AI's Python

   8 lessons

   It opens where being the human in the loop actually starts: controlling what leaves your keyboard, with redaction rules and a leak checker you build yourself. Then the literacy bridge from watching the loop to driving the tools: read a traceback to the real line, judge a JSON or dict shape against the contract you asked for, spot the bug in code you did not write, tell a code error from an environment one, and make verifying-the-AI plus git-as-undo a habit. Every lesson ends in a graded verify-it-yourself lab. Same deterministic, no-hardware labs. Two side quests close it out: the Bug Swarm arcade replays the whole section under time pressure, and Mermaid turns network data into diagrams-as-code.

5. 4. The Payoff: Build With AI

   3 lessons

   Module 2 had you run the loop with tools the course provided, and module 3 taught you to read, judge, and debug Python you did not write. This is the payoff, in two steps. First the working method: a repeatable loop for building with a model (pin the contract, generate, check, read the diff, revise with failures verbatim, commit at green). Then you run that loop on a real tool: hand the typing to an AI assistant, keep the standard, and verify the result with an oracle, a diff, and a hallucination check before you trust it. Same deterministic, no-hardware labs.

6. 5. Make It Durable: Source of Truth and Version Control

   2 lessons

   The day-one loop runs once; this module makes it last. Record what you discover as a canonical source of truth, then keep that source of truth in git so its history becomes your drift record over time, every change to the standard is reviewed before it lands, and you can roll the network back to any known-good commit. Same deterministic, no-hardware labs.

7. 6. Beyond the CLI: Device APIs

   3 lessons

   Lessons 1 through 3 talked to devices the way most automation still does: SSH in, run show commands, scrape the text. This module moves to the modern path, structured device APIs. With RESTCONF you GET state as JSON modeled by YANG (no regex) and PATCH config as data; with gNMI you stop polling and subscribe to a stream of state as it changes; and with NETCONF you edit a candidate datastore and use confirmed-commit so a change that cuts your own access rolls itself back. Same loop, sturdier interfaces.

8. 7. From Scripts to Tools

   4 lessons

   The bridge from scripts that work to tools a team can run. Every lab in this course has quietly used the same project shape: a README, the code, a grader, fixtures, a runner. This module makes that shape yours, starting with structure: one importable home for the logic so what you test is what you run, tests with clearly-invented fixtures, configuration split from code with secrets that never enter git, and a checker that judges any proposed layout, including one a model wrote, before a file moves. Then the tests directory earns its contents: the golden, regression, and fake-device tests automation engineers actually write, graded by a lab that runs your tests against implementations known to be broken. Then the tool learns the console habit of looking before it types: read actual state, diff it against the desired state from your source of truth, act only on the difference, and prove a second run changes nothing. And because a fleet is big enough that something always fails, the tool learns to fail like a professional: classify each failure by the action it demands, retry with backoff only where retry can help, decide continue or abort from the pattern, and report "47 of 50 succeeded, here are the 3" instead of "done". Same deterministic, no-hardware labs.

9. 8. Run It for Real

   3 lessons

   A tool that works is not yet a tool you run against production; this module is the operational layer around one that is. It opens with the ceremony of a real change window, where the prove-it habit from the day-one loop scales to a fleet and a process: gate the window on prechecks, render the staged plan with a canary first, judge the canary before anyone else gets the change, decide rollback against criteria written before rollout, and close with a change record an auditor can replay. Then the tool learns to leave evidence: structured JSON-line events instead of print statements, the run record that answers who ran what, when, against which devices, and with what result, refusals included, and redaction at the log boundary so the evidence never leaks what the run touched. And because the tool now has to run where nobody grooms the machine, on the scheduler box, in CI, on a teammate's laptop, it finally ships as one pinned image: environment and code frozen together, secrets injected at run time and never baked in. Same deterministic, no-hardware labs.

10. 9. The Read-First Agent

    2 lessons

    The course title made true. An agent is a loop, not a mind: a model proposes tool calls, policy you wrote decides what runs, and every step lands in an audit trail. You build the whole safety layer as plain graded Python: a tool registry with schemas, a read-only classifier that denies by default, guardrails for scope and blast radius, a plan validator that enforces read-before-write per device, and the audit entry that records refusals as honestly as successes. Wiring your tools into a real agent over MCP is the ungraded victory lap. Then the agent gets its doorbell: proposals land in a chat channel carrying the diff, the blast radius, and the rollback plan, a named human approves or denies, and silence is a deny; the webhook parser, the approval state machine, and the gate are all plain graded Python, with the real chat post as an optional victory lap. Same deterministic, no-hardware labs.