You know the process.
Now run it at depth.
The free course gets you a repeatable way of working with a coding agent. The Next Steps is what comes after that: the mechanics under the hood, orchestration across many sessions and many agents, evaluation you can trust, and the parts nobody writes down — legacy systems, security, cost, and getting a team to work this way.
Most people who work with agents plateau in the same place. The obvious wins land — shorter sessions, a project brief, a check command — and then progress stops, because the next problems are not prompt problems. They are systems problems: how do you know a change is correct when you did not write it? What does a review process look like when four agents are producing code? What happens the first time an agent touches a twelve-year-old codebase with no tests?
This course is 128 lessons on exactly that, each one built the same way: the mechanism explained properly, a worked example on real code, an exercise sized to a single session, and a solution you can compare yours against.
What is in it
Mechanics You Can Reason About
What is actually happening inside a request, at the level of detail that changes decisions: attention, position, tokenisation, sampling, reasoning budgets and caching.
10 lessonspreview 02
Context Engineering
Treating the context window as something you design rather than something that fills: retrieval, session shapes, poisoning, memory systems, compaction and very large inputs.
10 lessonspreview 03
Building Your Own Tooling
Stop working around your harness and start extending it: tools designed for agents, check commands as products, commands, skills, hooks, small MCP servers and scripted runs.
10 lessonspreview 04
Specification and Design
The discipline that decides whether unattended work is possible at all: interviewing yourself, acceptance criteria that bite, interface-first design, and specifying data, migrations and ambiguity.
9 lessonspreview 05
Orchestration and Multi-Agent Work
Running more than one agent without producing more than one codebase: subagents, parallel worktrees, orchestrator patterns, shared state, failure handling and knowing when to stop.
10 lessonspreview 06
Verification and Evaluation
The bottleneck, taken seriously: check ladders, property-based testing, a personal eval suite, reviewing at volume, detecting subtle breakage, and calibrating how much to trust.
10 lessonspreview 07
Legacy and Large Codebases
What changes when the code is old, large, undocumented or frightening: characterisation, seams, strangler patterns, undocumented behaviour and the politics of touching things nobody owns.
8 lessonspreview 08
Security, Safety and Supply Chain
The risks that come with delegating code and command execution: prompt injection, secrets, dependencies, permissions, data handling and reviewing security-sensitive diffs.
8 lessonspreview 09
Cost, Performance and Operations
Running this sustainably: where the money goes, latency and flow, model selection, budgets, failure modes in production and the operational habits that keep it working.
6 lessonspreview 10
Teams, Process and Craft
Making this work with other people: adoption, shared conventions, code review at volume, hiring and mentoring, and what happens to your own skill.
6 lessonspreview 11
Across the Stack
What actually differs by domain: frontend, data work, infrastructure, APIs, mobile and machine learning each break the general advice in their own specific way.
8 lessonspreview 12
Debugging and Incident Response
The skill agents help with least and cost most when done badly: hypothesis discipline, instrumentation, bisecting, production incidents, and the failures that only happen at scale.
8 lessonspreview 13
Architecture for Agent-Assisted Work
Design decisions reconsidered: what makes a codebase easy for agents, which classic trade-offs have shifted, and how to build systems that stay workable as generation gets cheaper.
6 lessonspreview 14
Research and Unfamiliar Territory
Using an agent to learn: evaluating libraries, reading unfamiliar code and papers, picking up a new language, and the specific ways confident wrongness bites hardest when you cannot check.
6 lessonspreview 15
Worked Projects
Six complete pieces of work, start to finish, with every decision and every mistake shown: a feature, a migration, an incident, a rescue, a greenfield service and a team rollout.
6 lessonspreview 16
Beyond Code
The rest of an engineer's job: writing, planning, estimating, technical decisions, runbooks, communicating with non-engineers, and knowing when not to use an agent at all.
7 lessonspreview
Read 16 lessons before you decide
One lesson in every module is open. They are not teasers with the substance removed — they are the real lesson, exercise and solution included. If those are not worth your time, the other 112 will not be either.
- What a forward pass actually does — Enough mechanism to stop guessing. Not a maths lesson — a working model of the thing you are delegating to.
- The context budget as a design artefact — Decide what goes in the window before the session starts, the same way you would decide an interface before writing the class.
- Why you should build tools — The gap between a good agent setup and an average one is mostly tooling, and it is cheaper to build than it has ever been.
- The specification is the product — Once generation is cheap, the scarce artefact is a precise statement of what to generate. That is now most of the job.
- When more agents help, and when they do not — Parallelism is real but narrow. A decision procedure, before you build anything elaborate.
- Verification is the bottleneck — Generation got a hundred times cheaper. Checking did not. Everything about how you work now follows from that asymmetry.
€149,00once, including VAT where it applies
- 128 lessons across 16 modules, about 11 hours of reading and a good deal more of doing
- Exercises with worked solutions, and a check-yourself question on every lesson
- Progress saved to your account, so it follows you between machines
- Lifetime access, including every revision — the tooling moves, the course moves with it
- No subscription, no account to create, no upsell afterwards
Payment is handled by Mollie (iDEAL, card, Bancontact, PayPal and more). Card details never touch this server. Already bought it? Get your link resent.
How buying works
- 1You enter an email address and choose a payment method on Mollie's page.
- 2The moment the payment clears, an email arrives with a link.
- 3Clicking it opens the course and keeps that browser signed in. Open it again on any other machine to unlock it there too.
Who this is for
| Buy it if | Skip it if |
|---|---|
| You already use an agent daily and have hit a ceiling you cannot prompt your way past. | You have not done the free course. Start there — it is the prerequisite, not a sample. |
| You are responsible for code other people depend on, and the review burden has become the bottleneck. | You want a list of prompts. There are none here; the whole argument is that prompts are the smallest lever. |
| You are deciding how a team should adopt this, and would rather not learn the failure modes in production. | You want tool-specific instructions for one product. This is deliberately tool-agnostic. |
Questions
Which tool does it assume?
None. Examples are written for a terminal agent because nothing is hidden there, and every technique is stated in terms that survive a change of product — context, tools, permissions, checks. If your agent can read files, write files, search and run commands, every exercise works.
How is this different from the free course?
The free course teaches a working process: one task per session, manage context, steer with a project brief, verify before you ship. This one goes under it. Why attention degrades and what that implies for how you split work. How to build your own tooling around an agent. How to evaluate output at volume. What changes in a legacy codebase, in a regulated one, in a team of eight. It is roughly five times the length and assumes everything the free course covers.
Will it go stale when the models change?
Parts of any course like this will. That is why it is built around mechanisms rather than products, and why revisions are included for good: when something material changes, the affected lessons get rewritten and you get the new version at the same link.
Can I expense it, or buy for a team?
Yes to the first — the receipt email is a valid one. For a team, email mail@pieterzandbergen.nl and I will sort out however many seats you need rather than making you buy them one at a time.
What if it is not for me?
Email me within thirty days and you get your money back, no argument and no form to fill in. The free preview lessons exist so that this should rarely be necessary.
What happens to my email address?
It is stored so that your purchase can be matched to your access, and it is used to send you the link and any revisions to the course. It is not used for anything else, and it goes nowhere near a mailing list.
Sold by Pieter Zandbergen · pieterzandbergen.nl