Course updates

August 2026

• Token Economics no longer has a browser lab. Token Economics: Run Your Assistant Like a Network teaches session habits: one task per session, compacting before the buffer forces you to, keeping the rules file short, routing mechanical work to a small model, and filtering a capture before you paste it. None of that is code you write once and keep. The lab asked for four small functions, and only the first, the context snowball, taught anything the lesson had not already put on the page. The other three were ordinary list handling and a routing table transcribed into if statements. The same four mechanics are now checked by the knowledge check on the Hands-on page, where every option carries the reason it is right or wrong, and answering all four correctly completes the lesson. You can still run the snowball math yourself, in the Try it box on Under the hood. Nothing else in the lesson changed.
• Every Try it box now asks how much support you want. Eighty-four of the ninety Try it boxes in this course and in the free foundation track offer three amounts of help on one objective. Guided names each step and leaves the structure on screen. Partial takes some of that away. Minimal gives you the objective and the case to handle. Guided is what you get by default, because giving someone new to Python too little help costs more than giving an experienced reader too much. The levels change how much support is on screen, not how much Python you need, so no level asks for syntax the guided level has not already put in front of you. Every minimal level ends on a case that returns a wrong answer without raising an error, because an error tells you something went wrong and a wrong answer does not. Six boxes stay in single mode, five because they teach one narrow observation and one because it is where you meet the browser runner.
• The course now reads at the Python level it promised. Can You Skip This Module? tells you that classes, decorators, comprehensions, and regex are deliberately absent, and puts comprehensions in the column of things you do not need here. Fifty-one lessons used one anyway, 86 times in all. Every one of them is an ordinary for loop now, with a counter or an .append(), written inside the vocabulary Just Enough Python teaches. Four needed more than a substitution: lesson 12 teaches a bug that is an early return, so that loop keeps its bug; lesson 23 contrasts range(start, end) with range(start, end + 1); and lesson 28 asked you to write a lambda in its Your turn, which is a plain function now. All 86 blocks were run before and after the rewrite and not one of them changed what it prints. Nothing was removed.
• Python in the Try it boxes is indented the way the course teaches it. The course tells you to indent with four spaces, and every Try it box was arriving with two. The lesson files were right the whole time, and the page builder was taking two spaces off every indented line on the way to your screen. All ninety boxes reach you at the indentation they were written with now, so the code you copy matches the code you are told to write.
• The free foundation track got ten new terminal recordings and four Python fixes. Lesson 17 recommends Python Foundations for Network Engineers without requiring it, so its changes are listed here too. The ten terminal demos in that track were typed by hand, keystrokes and output together, so the output was only ever as good as the author's memory. Eight of them were wrong. Twelve printed values did not match what the code produces, including a hostname that printed CORE-SW01 when the input said den-core-sw01, and a switch built as a C9200L-48P-4X that printed as a C9300-48P-4X. Twenty-six continuation lines showed a >>> prompt where a real Python session prints dots, so copying what you saw gave you a syntax error. All ten are recorded by running the code now, so the output is whatever Python said. Separately, four places used Python the track had not taught yet. The lesson 10 capstone used a conditional expression twice. Lesson 1 said conditionals arrive in lesson 3 and then used one in the very next runnable block, and it indexed a list before the course had said what a list is.
• The Network FDE method now runs inside the technical lessons. An earlier entry on this page said a separate module was coming for turning stakeholder complaints into validated problems. That method shipped, but not as a separate module. It runs inside the lessons you already have, so you practice it on the same work instead of reading about it first. Lesson 1 now opens with a district office that reports slow mornings. The IT director asks for an access-switch refresh, an operations technician blames the wireless controller, and the help desk lead counts about forty cannot-connect tickets between 8 and 9 each weekday. Before the LLDP crawl runs, you tag each statement as a report, a measurement, an assumed cause, a proposed fix, or a broad goal, then pick the sources that can confirm or contradict each one. The crawl also records the neighbors it could not reach and who owns the ticket count. Every lesson in the paid course was revised this way. Nothing was removed, and it is all in the course you already own, at no additional cost.
• The course is growing into the Network FDE course. A new lesson, The Network FDE Role, now opens the course: what a forward deployed engineer is, the verified market evidence with sources, how the role translates to network infrastructure, and a map from every module of this course to the published FDE skills bar. Each module description now names the line of that bar it serves. More is coming: a method for turning stakeholder complaints into validated problems, an engagement module, and a capstone that grades your problem statement rather than your code. Everything lands in the course you already own, at no additional cost.
• Twenty-seven lessons picked up an illustration. These are the figures a flowchart could not carry: the polling blind spot that hides a flapping uplink, the same interface records in a dict and in a list, the one extra space that emptied a serial number, the confirmed commit that restores access when nobody answers, the ports a filter removed before any check ran, and the audit log that said done while three routers had taken nothing for eight months. Each one uses its lesson's own names and numbers, and follows the light and dark themes. Nothing was removed to make room.
• Nine lessons picked up a diagram. Each one draws a mechanism the prose already described but never showed: the queue and visited set behind the discovery crawl, the call stack unwinding into a traceback, the two commands that sort a failed import, the predict-run-compare loop, the loop and decision and return inside one function, the import boundary that makes tested code and run code the same code, and the fake device answering a command nobody recorded. Nothing was removed. Every diagram in the course can now be opened full screen.
• Reference tables across most of the course. Twenty-nine lessons picked up a short table beside the prose: what each tool in the toolkit is for, the four data shapes and how you reach into each, what to check first for every error signal, how much verification a blast radius earns, the NETCONF datastores, the retry rule per failure, and the approval path per change shape. Nothing was removed to make room, apart from one JSON mapping list that its table covers completely. Tables also got a proper look on the page instead of the browser default.
• Idempotency as a Discipline, Under the hood. The convergence diagram sent the verify step straight to a converged result, so the check could never fail. It now branches on whether the delta is empty, and a run that does not converge reports that instead.
• Error Handling for Automation, Under the hood. The failure-handling diagram sent "next device" to the final report, which made a fleet run look like a one-device run. It now loops back to the next device, and a retry returns to the device instead of reclassifying the result it already has.