Wait, WTF are courses for?
Practicing judgment still matters (a lot)
On January 30, 2025, I wrote that monetized courses about AI skills were “like a healing crystal sold by a guy named Brad at a wellness convention.” Eighteen months later, I am teaching a course (ostensibly about AI) that begins on August 3rd1.
This deserves an explanation.
That old essay (Wait, WTF are AI Skills?) attacked $2,979 AI literacy classes cropping up at the time that gave new names to old management skills, taught common sense, and handed out a certificate. I ended with “No certification required.” I still believe that.
Then yesterday frm Hacker News I read an article from a company called Capabase make an argument against courses. Most people do not want eight modules and a PDF, they say. They want a specialist’s checks, examples, limits, and decisions inside the work, at the moment the work happens. Package the method as an agent skill and sell it on their marketplace.
That may be a good argument against a bad course. But it is not an argument against learning. The line at the center of the piece is “knowledge is cheap. judgment is not.” That is also precisely the reason I built my course.
An agent skill installed into Claude or Codex can sort of carry judgment into a task. It can tell the agent which evidence to gather, which warning to ignore, and when to stop instead of bluffing. I build, talk about and use agent skills myself2.
But that judgment remains borrowed. The operator (that is most likely YOU my dear friend) gets a result without learning why this check matters, when its premise has failed, or what to do when the live case fails. A agent skill can lend you judgment. It cannot make the judgment yours.
Steering agents well makes that gap obvious. From the outside, steering looks like a few simple steps: give the agent one missing fact, point it at a working example, reject a bad plan, interrupt an action, or cancel and start again. The list in reality is quite short.
The high skill ceiling comes from choosing the right actions and using them at the right time.
Is the agent missing a fact, or is the whole premise wrong?
Did it take one bad step that deserves an interrupt, or has it returned to the same mistake often enough that the prompt you brief it with must change?
Should you let the run continue because the work is cheap to undo, or stop now because the next tool call crosses a line?
The evidence arrives a piece at a time, and every correction changes what happens next.
18 months ago I intimated this was “old-school management in AI drag” and used it as an insult. Time deep in the work changed my view. Management is easy to name and hard to do well. Steering an agent has the same very high ceiling, only your worker now moves much faster and can be confidently wrong at machine speed.
My evidence is local from building many products with agents over the last year and a half across 10s of thousands of sessions in 100s of repos. In one of those projects I interrupted the work of my agent was attempted to do 614 times. I wrote a short book about the experience and distilled patterns from it if you’d like to read it.
Numbers like these are not a claim that everyone should work as I do. But it helps rationalize why I decided to teach. If I published only the patterns, I would hide the mistakes that give each of them meaning. Its a package of answers that discards most of the learning.
So I did not build a course around product tours or longer prompts. I built a three-week live practicum around repeated decisions. Students will build a small agent harness called prove-it, watch it accept a wrong result, strengthen the check, and carry it into a real repository of their choosing where the result matters. In each live session they predict first, decide together, try the move, inspect what happened, and apply it to their own work. On Demo Day, each person must answer one question: what does this evidence still not prove?
Its on Maven which I’m very excited about, mostly because its a live cohort. The research out there points that live active learning has benefits. A 2014 review of 225 STEM studies found that active learning raised performance by 0.47 standard deviations A 2019 randomized classroom study found something a little bit stranger: students doing active work learned more but felt as if they learned less, in part because the work required more effort. Both warn against confusing a smooth explanation with learning.
That confusion matters more now because AI can and will make every explanation smooth. It can summarize the book, answer the question, generate the checklist, and place the checklist inside the task. We should use all of that.
If it’s not right, don’t do it. If it’s not true, don’t say it. — XII. 17
But a good course does something else. It makes you state what you think will happen, act, meet the result, accept correction, and try again. Someone who knows the failure modes can still stop you. A cohort adds other people’s failed attempts to the shared practice. A real hands on project tests whether learning really leaves the room.
The question we must ask ourself is not whether AI can carry a method into work because we know it can.
We have to ask: who is practicing the judgment to overrule it?
If you’re experienced with coding agents but want to go deeper in perfecting your inner loop, I encourage you to check out the lightning lessons recorded in this repo and consider signing up for the inaugural cohort: https://github.com/specstoryai/hardcore-agentic-engineering#the-lightning-lessons. I promise a very fun and engaging time!
I was recently on Hugo Bowne-Anderson’s podcast about this very topic