Whatever your title says. Here is why.
Video lessons, hands-on labs, real feedback.
Course 0 is a one-time $99, built and tested on Claude Code.
Course 0 teaches the plan-first developer workflow: judgment before the agent builds.
An AI that builds in seconds leaves the deciding to you: breaking the work down, questioning the plan before it builds, judging whether what comes back is good enough to ship. On a real engineering team, those are the judgment calls a senior engineer makes every day.
You have not been handed a faster keyboard. You have been handed a senior engineer's job, directing a junior of your own. On day one.
This is why ramping up as a junior is so hard now. The job asks you to produce like a senior, and you can. Open an agentic coding tool today and working code comes out right away. Right up until understanding and judgment are needed.
Whether you already ship with AI, want to know why what you ship works, or are finding your way into engineering for the first time.
"Command the agent, don't just prompt it."
You hand tasks to an agent to keep up with the velocity the industry expects of you: your own understanding falls behind what you ship. Course 0 teaches a method that keeps the two moving together.
"Catch it before it ships."
You ship fast with an agent, and when it breaks, you can't solve it. Course 0 is not about slowing down. It is a method for staying in the loop just long enough to catch what would have shipped broken.
"Learn the workflow before the framework."
You can code a little, and you are looking for a real way in. Course 0 gives you the plan-first method this whole series is built around, before Courses I through IV teach you the systems it directs.
Anthropic ran a randomized trial with 52 mostly junior developers, half coding with an AI assistant, half without. The ones using AI scored 17 percentage points lower on a quiz about the code they had just written, roughly two letter grades. The ones who asked it to explain, and asked why, held their scores. Course 0 teaches that habit as a workflow, not a personality trait: plan first, judge what comes back, and get sharper with every task instead of weaker.
Anthropic, "How AI Impacts Skill Formation" (Shen & Tamkin, 2026); the paper reports a 2 grade point gap. arXiv:2601.20245
This course is the reps, and reps come two ways. Scaffold, the plan-first skill the whole method runs on, is free and installable today: try it on your own code before you buy anything. Course 0 is where you put it to work under real constraints: two hands-on labs, a written assessment, and a three-part challenge that has you build up a real chatbot instead of watching someone else build one.
Free material teaches you the concepts. It does not tell you whether you applied them correctly. Here, the written assessment is graded against a rubric with feedback you can act on, and you can retake it as many times as you need. Challenge 2 is graded on the plan conversation you had with your agent. Challenge 3 is graded on the brief you wrote and the go or no-go call you made, not just whether the code runs.
20+ years building commercial software. 10+ years teaching at the university level. Most practitioners can't teach. Most teachers haven't built.
Course 0 is $99, one time. Every purchase carries a 7-day money-back guarantee. Courses I through IV are one $299 bundle after that, open to anyone, no à la carte.
Move through Course 0 on your own schedule. What waits at the end of a lesson is real feedback on what you built.
A retake never shows a lower score than a prior attempt. Work the assessment until the concept lands, not until you get lucky, and the three challenges are graded the same way: on the decision, not just the output.
Move through the eight lessons and two labs on your own schedule. No mandatory live sessions, no calendar gates.
Self-paced, $99 one time. Prefer to try the method first? Scaffold is free, installable today.
Course 0 does not tell you to use AI less. It teaches a specific workflow: settle the plan before the agent builds, then judge what comes back. Scaffold is the free tool that runs it, plan-first from your first lesson.
This is not passive video watching. You run the method yourself, on a real codebase, and get real feedback on what you decided.
Lab 1 runs craft mode for real, against a supplied starter repo: you review the plan, push back, and confirm what gets written to the wiki. Lab 2 runs direction mode: you write the brief, step out while the loop runs, and make the go or no-go call on what comes back.
Three challenges against personal-llm, a real chat app that runs a language model on your own machine. You start by reading an unfamiliar codebase closely enough to write your own questions about it, then direct your junior engineer through two small, real features.
A ten-question checkpoint, answered in your own words, over the core judgment concepts from all eight lessons.
After every task, the agent writes down what it learned about your code and your decisions, in plain text you can open and read yourself. It compounds: the tenth task starts with everything the first nine taught it.
That moment keeps its own schedule. Production breaks at 2 AM and you are the one holding it. The code that failed is code you shipped, but the AI wrote it, and you never really understood it. So you sit there rereading a stranger's logic, line by line, while the thing you built stays down.
That is the rare version. The daily version is quieter. Code review asks why you did it this way. Standup asks you to walk them through it. An interviewer asks how a project with your name on it actually works. And you have no answer, because the AI decided.
Code you can produce but cannot debug carries a debt. It has not come due yet. Code you cannot explain carries the same debt, coming due one question at a time.
Maybe you have felt the quiet suspicion: every AI-assisted ship is a rep you did not take. If that suspicion is right, the way you are using AI is making you faster and keeping you junior at the same time.
So how do you deal with this? Frameworks and structure. Course 0 does not tell you to use AI less. It hands you an opinionated method: a different way of using AI than what you are used to. Not a faster version of the same thing. A different thing entirely.
The method grows your judgment as an engineer and makes you build faster and more robustly, because you hand the AI a solid plan before it writes a line of code. That method is called loop engineering: setting guardrails and letting the agent iterate with the human out of the loop.
Course 0 makes one deliberate change to that: it starts you in the loop on purpose, every round, until the plan is solid. Your first lesson shows you what staying in the loop catches.
A plan you settled is a map back through the code, and an answer when someone asks why.
At the center of it is an agent you build up over the course, not one you simply use. Most AI coding work resets between questions. This one keeps a running written record of what it learns about your codebase and how you work. That record is called the wiki, and it compounds: the tenth task starts with everything the first nine taught it, instead of starting from zero.
What makes that possible is scaffold: a skill that runs on top of Claude Code, and the centerpiece of this whole way of working. It is public, installable today from the Systems Thinking Lab marketplace, not something built exclusively for this course. It turns Claude Code into a plan-first process: you settle the plan together, then Claude Code builds it. It does that three ways.
After every task, the agent writes down what it learned about your code and your decisions, in plain text you can open and read yourself. Reading it is part of how you learn too, not just how the agent remembers: the record lays out the reasoning behind a decision, not only the decision itself.
Checks that hold once you have made a decision, so the agent cannot quietly go back on something you already settled.
Two ways to work with the agent. In craft mode, you and your agent settle the plan together before it builds. In direction mode, you hand scaffold a brief on what you want built and step back. Your junior engineer proposes the work and revises it; a second agent, holding the seat you practice in craft mode, attaches findings to what comes back, for you to judge. You will practice both, and learn when each one is the right call.
Inside that wiki is an architecture page, written in a vocabulary of seven building blocks: a database, a queue, a background worker, and four more. It is the small set of pieces every system is actually built from. Course 0 never stops to teach it as its own lesson. It names a block only at the moment a decision turns on how that block behaves, and points you at Courses I through IV, which teach it in full. That vocabulary is also the standard: once you have it, it is what you judge an AI's plan against.
That is Course 0: an opinionated way to produce like a senior, learn as a junior, and develop the "good taste", the judgment, of a software engineer.
Most people using AI for development hit the first one, some of the time. The other two, rarely.
The course is built so the same work that ships the feature is the practice that grows the judgment. Same tasks. Same tools. Different compounding.
Course 0 is $99, one time. Courses I through IV are $299, one bundle, open to anyone.
If your AI experience so far has been a chat window you paste code into, or a tab-complete tool that finishes lines while you type, this is a different kind of tool. What you have been doing is the conversation. This tool also does the work: you talk the plan through the same way, and once you agree on it, the tool builds it in your own project files, without you typing every line.
The method itself, the plan-first back-and-forth you practice in the labs, is a plain-text playbook, not something locked to one tool. If you already use another agentic tool (opencode, Cursor's agent mode, and similar), scaffold installs into it with one command from the same public repo. That path is untested and unsupported here.
Claude Code itself needs a paid Claude plan, Pro or higher. That subscription is between you and Anthropic, starts at $20 a month at the time of writing, and is not part of Course 0. The scaffold skill is free and runs inside it.
A hard floor to check before anything else: Node 22 or newer. On an older Node version, installing this course's tool does not fail loudly. It silently resolves to an older, incompatible version instead, and the symptoms show up later, disconnected from the cause. Run node --version before your first lab. If it prints anything older than 22, install the current version from nodejs.org and run the check again.
Self-paced. Eight lessons and two hands-on labs where you run the method yourself instead of watching someone else run it. Then one written assessment: ten short questions, graded with feedback, unlimited retakes. After that, three practice challenges on a local chatbot you take over and make your own, and three wrapups to close it out.
Nothing makes production stop breaking. What changes is whether the one holding it at 2 AM understands what shipped.
You do not leave Course 0 with a folder of prompts. You leave with a working agent setup you keep: the compounding wiki, the rails you set, both working modes. The course walks you into that setup step by step, and scaffold is public today: install it and look before you decide.
Course 0 is a one-time $99, built and tested on Claude Code.
