Driving Coding Agents
A coding agent is a model wrapped in a control loop, a tool registry, a permission layer and a context manager. Almost everything that determines whether it is reliable lives in that wrapper rather than in the model — which is good news, because the wrapper is the part you can see, configure and debug.
This course is for engineers who already use a coding agent and want to drive it deliberately instead of hopefully. It assumes you can read code and use a terminal. It assumes nothing about machine learning, and it will not teach you to write prompts.
Read the modules in order the first time. Each one depends on the one before it: you cannot govern context until you know what the harness puts in it, and standing instructions only make sense once you know when they are loaded. Module 5 is a capstone — a single investigation carried from “which model should I run?” through finding a documented feature silently discarded, proving it from inside the container, and writing it up so the vendor could act on it. The method is the lesson; the specific product is a worked example.
The recurring theme is worth stating up front, because it is the thing most likely to change how you work: a system that reports success while producing something broken is more dangerous than one that crashes. A crash names a file and stops. Silent success ships. Most of what follows is about arranging for failures to be loud.
Module 1 — The Harness You Are Actually Using
An agent is a model wrapped in a control loop, a tool registry, a permission layer and a context manager. Reliability comes from that wrapper, not from the model — so start by knowing what is around it and which mode it is running in.
Module 2 — Governing Context
The context window is a budget with an eviction policy, and quality degrades well before the advertised limit. What enters, what stays, and what gets summarised is a decision someone has to make — and if you do not make it, the default is to accumulate until the answers quietly get worse.
Module 3 — Instructions as Infrastructure
Standing instructions are the cheapest lever you have and the easiest to ruin. Why skills beat persistent agents, what a skill framework looks like in practice, the order the pieces are meant to run in, and how to write one that earns its place in the context window.
Module 4 — Beyond a Single Agent
What changes when one agent becomes several, and when an assistant becomes a service you depend on. What orchestration platforms actually add over subagents and parallel sessions — and when one agent is still the better answer — then the capability ladder from chatbot to autonomous system, and a real migration between platforms with the costs left in.
Module 5 — Capstone: Diagnosing an Agent Stack
One continuous investigation, start to finish: choosing where to serve a model, finding that a documented feature is silently discarded, proving it from inside the container, generalising the failure modes, and writing it up so the vendor can act. The point is the method — everything here is a worked example of it.