AI Coding Agents: Claude Code, Codex, Cursor & Copilot

This course contains the use of artificial intelligence.

Coding agents arrived faster than the vocabulary for them. You are told that four tools are all different, and also that they are all the same thing. This course settles that question by explaining the machinery instead of selling a tool. By the end you understand what an AI coding agent is, how one is built, what words the field uses, and what these tools look like on real teams, and you have tried the judgement calls yourself on your own material.

Who this is for. Developers who want to know what is actually happening when an agent edits their repository. Tech leads who have to decide what their team standardises on, what it costs, and how the work gets reviewed. Adjacent specialists, in testing, in security, in product, in compliance, who are now in the room when these decisions get made and need the concepts rather than the keystrokes.

Who this is not for. If you want a code-along where you type what the instructor types and end up with an application, this is the wrong course. There is no screen recording here and nothing to install. If you only want a feature tour of one tool, the market already has several. And if you want someone to tell you which tool is best, you will be disappointed on purpose: the honest answer is that the architecture is shared and the choice comes down to where the work lives, how it gets reviewed, and what it costs per accepted change.

What makes this course different. Four things. First, every module follows one real, sourced case from beginning to end, including the part where something broke. Second, honesty is structural, not decorative: one whole lesson walks through a randomised trial in which experienced developers were measurably slower while feeling faster, there is a full catalogue of the ways agent runs fail, and there is a named lesson about who this way of working does not suit. Third, this is a map rather than a list. The harness-and-model frame is built once, in the early modules, and then reused on all four tools, so you see connections instead of four disconnected feature tours. Fourth, every module ends with one short judgement task with a model answer, done on work you already have.

The modules, and the case each one follows.

• What an AI coding agent is. The case is a large retailer handing an agent its hardest task inside a very large codebase, then rebuilding its workflows around what it learned.

• What an agent is made of. The case is a controlled study across ten open-source repositories that ran the same pull-request tasks with and without a committed instruction file.

• The words people use. The case is a vendor redesign that broke setups people had already built habits and glue around, which is where lock-in actually lives.

• Claude Code and OpenAI Codex on one task. The case is the Northwind Ledger authentication refactor, a composite engineering task named as composite on screen, taken through both terminal agents from the ticket to the limit each one hits.

• Cursor and GitHub Copilot on one task. The case is the Northwind Ledger checkout bug, the same fictional product and different work, fixed once inside the editor and once as a pull request.

• A working week with agents. The case is a research organisation that measured developer productivity, found the opposite of what its participants believed, and then publicly redesigned its own experiment.

• What comes next. The case is a private bank taking coding agents through risk, information security and data protection before a single developer got access.

That last module, lesson by lesson. It opens with the key terms for context engineering and spec-first work. Then: know whether this way of working suits you, which is the honest exit ramp. Understand context engineering and what survives it, separating the three practices that hold from the methodology noise around them. See the four agents side by side on one table, on axes chosen because they do not go stale. See what a regulated rollout has to prove first. Watch a bank take agents through compliance. Know what this course skipped and where to get it. And finally, try it: rewrite a one-line ticket as a spec, where the graded point is the list of what the agent may not touch.

What this course does not cover. No prices and no per-plan usage limits, because they change constantly and because a course that names them teaches you a number instead of a method. No benchmark rankings, since a score measures the model and the harness together. No model names. No installation walkthroughs, no configuration reference, and no screen recordings. No language or framework tutoring: the example code is there to be read, not to be run. No deep dive on writing your own tool servers. Where something was left out, the last lesson says so and says where to go for it.

You will need no prior experience with any of these four tools. You will get more out of the course if you have read other people's code before, because reviewing work you did not write is the skill this whole subject turns on.