Watched subsystems
Make AI coding agents actually reliable.
The model is not your bottleneck. The system around it is. Learn to build the environment, state, verification, and control layers that turn a capable agent into a dependable one — then build an agent that works for you between sessions.
Same model. Different system. Different outcome.
The uncomfortable part is that the failure is measurable, and it is not the model's.
What developers felt
20% faster
Experienced open-source developers, after a randomised trial using AI tools on their own repositories, estimated the tools had sped them up.
What was measured
19% slower
The same developers, on the same tasks, were actually slower with the tools than without them — and did not notice.
That is not a model problem. It is a harness problem: unclear scope, missing conventions, no verification the agent can fail, and state that dies with the session. Every one of those is fixable, and every one is a module in this course.
Source: METR, randomised controlled trial of experienced open-source developers (2025). Effect sizes are from that study; your mileage on your own repository is exactly what the labs measure.
What actually changes on Monday.
Not a mindset. Four concrete files and one loop.
| Before | After |
|---|---|
| You re-explain the project every session | The repository explains itself; the agent initializes before it touches code |
| The agent says done; you find out later it wasn't | Done is a command that either exits zero or doesn't |
| One task quietly becomes four unrelated changes | Scope is a written surface with explicit exclusions |
| The same class of bug returns next sprint | Each failure becomes a rule, so the class is gone |
| Long tasks fall apart when the context resets | State lives on disk; a restart costs nothing |
Six courses. One price. More coming.
Every course is included in every paid tier — today's and the ones that ship later.
Harness Engineering
Make AI coding agents actually reliable.
Start here if you use a coding agent most days and still fix the same failures by hand.
You leave with your own harness: repository conventions the agent can read, rules and commands it obeys, verification gates it cannot talk its way past, and a session lifecycle that survives restarts.
Agent Systems
Build an agent that remembers, acts for you, and can be trusted.
Start here if you want one agent that works on your behalf between sessions, not only while you watch it.
You leave with a running personal agent — not a demo. It remembers across sessions, reaches your tools through a wrapper that isolates secrets, runs on a schedule, and is small enough that you can audit every line.
AI Solutions Architect
Design, cost, secure and prove AI systems a client can sign off on.
Start here if you design, cost or defend AI systems that a client or sponsor has to sign off on.
You leave holding an Architecture Dossier for a real engagement, built one file per lesson: charter, budgets, decision records, diagrams, eval plan, cost model, threat model, compliance annex, runbook and rollout plan. It is the document a buyer signs and an engineering team builds from.
Agent Fleets
Run many coding agents without drowning in their output.
Start here if one coding agent already runs reliably for you and you want several at once, on and off your own machine.
You leave with a Fleet Kit you can run tomorrow: a topology decision, an isolation launcher that stops port and database collisions, a permission and credential policy, a venue off your laptop, a supervision protocol that pages you for the blocked agent, a landing pipeline with gates that survive parallel runs, an audit trail, and an on-call runbook.
Graph Engineering
Four shapes cover almost every agent graph you'll build.
Start here if a single agent loop can no longer hold your task and you need to split the work across agents.
You leave able to look at any multi-step agent task and answer three questions without guessing: which steps genuinely depend on each other, where the graph should fan out instead of chain, and whether the task earns a graph at all instead of staying a single loop.
Loop Engineering
Keep the loop's own measuring stick honest while it runs unattended.
Start here if a coding-agent loop already runs for you and you need it to run overnight without quietly gaming its own score, burning its budget, or drifting off its real goal.
You leave with every guard rail a self-improving loop needs before you let it run overnight unattended: a locked scorer, a worthiness screen, a ratchet, a spend budget, a goal hierarchy, a triage sheet, and a canary-and-ledger process for scaling it to more than one project.
Every lesson has the same four beats.
You always know what you are about to spend your evening on, and what you will be holding at the end of it.
01Failure first
The lesson opens on something you have already had go wrong.
02The mechanism
Why it happens, and the smallest system change that removes it.
03Self-check
Questions inline, answers hidden until you commit to one.
04Deliverable
A named artifact you add to your repository before moving on.
Two paths per lecture
A concise path when you need the rule, a detailed path when you need the reasoning. Same lecture, you pick the depth.
Everything runs
Every file, rule, and command is written out in full inside the lesson. Nothing is behind a repository you have to go clone.
It comes back
Completed lessons enter a spaced-review queue, so what you learned in week one is still there in month three.
Worth being honest about.
This is a systems course for people who already write software. It is not an introduction to AI.
A good fit if you
- Already use a coding agent daily and get inconsistent results
- Ship to production and care what happens after the PR merges
- Would rather fix the system once than fix the same bug four times
- Are willing to write files the agent reads before you write code it produces
Not for you if you
- Have never run a coding agent on a real repository
- Want a list of prompts to paste rather than a system to build
- Believe the next model release will make all of this unnecessary
- Are looking for an introduction to programming
If you are somewhere in between — you have used an agent a handful of times and it went badly — start with the free lesson. It is the whole diagnosis in twelve minutes, and it costs nothing to find out.
Why not just keep reading blog posts?
A fair comparison of the three real options, including the free one.
| What you get | Blog posts & threads | Figure it out yourself | This platform |
|---|---|---|---|
| Techniques | |||
| Ordered so each builds on the last | — | • | |
| A named artifact per lesson | — | — | |
| Graded project labs on your own repo | — | — | |
| Tracked progress + spaced review | — | — | |
| A certificate per course | — | — | |
| Template pack, copy-ready | — | • | |
| Kept current without re-buying | • | — | |
| Cost | Free | Weeks of your time | One payment |
Blog posts are genuinely useful and several are cited inside the lectures. What they cannot give you is order, a deliverable per step, or something that checks your work.
Built by Noam Loewenstern, who runs these systems daily.
The curriculum is the write-up of a harness in continuous production use — including the one that maintains this platform.
Noam Loewenstern
Software engineer who runs fleets of self-improving coding agents across production repositories.
Noam started where you are: a heavy user of AI coding agents, fixing the same failures by hand. Today he runs a multi-role agent team that ships real product code every day, and he built this academy with the same loops it teaches. These lessons pass on what he learned the hard way: not just the tools, but the thought process behind each decision.
Every technique here was written down because it fixed something that was actually broken. The platform you are reading runs its own harness: a scheduled agent loop with a role rotation, a written contract, a verification gate it cannot skip, and a state file it hands to the next run. When that loop fails, the failure becomes a rule — and often a lecture.
That is the entire argument of the course, applied to the course.
Student results
Reserved for real, attributed outcomes from students — nothing invented, nothing placed here until someone has actually said it. If the course changed how your team ships, we would like to quote you.
One payment. Every course. Forever.
Not a subscription. Not per course. The platform adds courses and lectures over time, and your purchase follows them. Starts at $39 one-time.
- All 6 courses — and every future one
- 80 lessons and 22 project labs
- Tracked progress, spaced review, a certificate per course
- Copy-ready template pack
- Labs on every available course, run on your own machine (Pro)
- 30-day money-back guarantee
Questions, answered
Ordered by the reasons people actually hesitate.
Do I need to already be good with agents?
You need to have used one. The courses assume you have run Claude Code, Codex, or a similar CLI agent on a real repository and been disappointed at least once. They do not assume you know what a harness is.
How long does it take?
Self-paced. Harness Engineering is about four hours of reading across 23 lectures; Agent Systems is about two. The project labs are real work on your own repositories, so they take as long as your agent takes. Most students finish a course in one to two weeks of evenings.
What if it's not for me?
30-day money-back guarantee, no questions asked, no form to fill in. Email and it's refunded.
Is it really one payment?
Yes. One payment, lifetime access — including every future lecture and every future course on the platform. No subscription. Multi-seat billing (Team) is in development.
What exactly am I paying for?
The learning system around the material: structure and sequencing, tracked progress, concise and detailed paths per lecture, self-checks, spaced review, labs and a certificate on every available course, the copy-ready template pack, and lifetime updates.
What's free?
Reading. Every lesson of every course is free to read, no card required. Paying unlocks the doing layer — saved progress, recorded quiz answers, verified completion, spaced review, and the labs and certificate on every available course — from $39 one-time.
Which agents does this cover?
The material is agent-agnostic: it teaches the environment, state, verification, and control systems any CLI coding agent needs. Examples and labs use Claude Code and Codex; the techniques apply to Cursor, Aider, and whatever ships next.
What does BYOK mean?
Bring-your-own-key. Rubric labs are graded inside your own agent, on your own Claude or OpenAI key; checker labs run a local script with no AI at all — your code and API keys never touch our servers. Pro and Team also bank grading credits for server-side grading, which is in development — credits are granted now and spendable when it ships.
Will this be out of date in six months?
The model names will be. The systems will not — that is the whole argument for teaching the harness rather than the tool. Updates are included forever, and the curriculum is edited continuously rather than re-recorded every year.
Start where it costs nothing.
Every lesson is free to read, no card needed. Start with the first one. If it does not change how you brief your agent tomorrow, nothing else here will either.