A free course
Building Software
Engineering Fundamentals for the Agent Era
When AI agents write the code, engineering is knowing exactly what you want, writing it down so it can be checked, proving with evals that you got it, and understanding what was built well enough to run, secure and change it.
Four ways in
-
If you are new here
Who this course is for
Who the course serves, who should start somewhere else, what you need before the first lesson, and what you can do once you finish.
-
If you use agents today
How Agents Work and How They Fail
The mechanics of language models and agent loops, the failure modes that follow from them (invented APIs, agreement with a bad spec, confident wrong fixes, injected instructions, different results on every run), and the more common cause of a wrong result: a wrong or partial target. It needs nothing else in the map.
-
If you want the essentials
The core path
25 lessons in reading order, about 4 hours, starting with Articulating the Ideal State. They are marked Core 1 to 25 in the contents below.
-
If you want to know where you stand
Test yourself
Every lesson ends with a check and every section with a test, 46 checks and 9 tests in all, and the runnable examples in the lessons run in your browser.
Contents
Each area names the specific mistakes agents make that its knowledge lets you catch, the depth a working developer needs, and a drill built on flawed agent output. Its competencies are things you should be able to do without AI; they are the learner's test. The 25 subsections marked Core form the core path, in reading order; the others show their depth, how far a working developer needs to go: recognize, explain or do.
0Introduction
Who the course is for, how it works, and enough code to begin.
1Ideal State
Knowing and Writing Down What You Want
Getting what you want out of your head and into one document, precisely enough that done is defined before anything gets built.
2Verification and Evals
Proving You Got What You Wanted
Your criteria say what you want; tests and evals check them on every change, and the loop climbs the build toward them.
3The Machine
How Code Actually Runs
From source code down to silicon and out across the network.
- Hardware and the Operating SystemDepth: explain
- Languages, Compilers and RuntimesCore 8
- Representing Numbers, Text and TimeCore 9
- Networks and ProtocolsDepth: explain
4Math and Algorithms
Enough logic, complexity, statistics and estimation to check a claim without asking another model.
- Logic and Discrete MathDepth: explain
- Algorithms, Data Structures and ComplexityCore 10
- Probability and StatisticsDepth: explain
- Back-of-the-Envelope EstimationDepth: do
5State
Data, Concurrency and Distribution
The hardest bugs live where data is stored, shared or spread across machines.
- Data Modeling and DatabasesCore 11
- Transactions and ConsistencyCore 12
- Concurrency and Race ConditionsDepth: explain
- Distributed Systems and Partial FailureCore 13
6Design
Structuring Systems That Stay Understandable
Structure is what lets a system keep changing without breaking.
- Managing ComplexityDepth: do
- Components and ArchitectureDepth: explain
- Interfaces and APIsDepth: do
- Error Handling and Failure PathsCore 14
- Where Logic Meets the DatabaseCore 15
- Frontend and BackendDepth: explain
7Operations
Running Software in Reality
Seeing what production is doing and changing it without betting the system on each release.
- DebuggingCore 16
- ObservabilityCore 17
- Reliability, Redundancy and RecoveryDepth: do
- Shipping Change SafelyCore 18
- Performance and CapacityDepth: do
8Security
Boundaries, Data and Trust
Know what is sensitive, where the boundaries are, and who is allowed to do what.
- Security Boundaries and Threat ModelingDepth: do
- Authentication and AuthorizationCore 19
- Sensitive Data and SecretsCore 20
- Protecting Data in Transit and at RestDepth: explain
- Untrusted Input and InjectionCore 21
- Dependencies and the Supply ChainDepth: explain
9Delegating to Agents
Harness, Boundaries and Accountability
How agents work and fail, how to tell them what you want, how to bound what they can do, and how to judge the evidence that comes back.
- How Agents Work and How They FailCore 22
- Telling Agents What, Not HowCore 23
- Your Harness: Standing Context Under the Bitter LessonDepth: do
- Reading What Agents Built: Understanding and Risk-Based ReviewCore 24
- Orchestration, Permissions and GuardrailsDepth: explain
- Accountability: Owning Code You Did Not TypeCore 25
The ironies of automation
AI agents can now write most of the code in a project, and they increasingly test it, review it and coordinate other agents. Code can be entirely machine-written and still be good engineering. The line between engineering and vibe coding is not whether AI wrote the code. It is whether you know what you wanted, can prove you got it, and understand what was built and why it was built that way.
Automation has a known trap, which Lisanne Bainbridge named the ironies of automation in 1983: machines take over the easy work and leave people the hardest parts, with less practice at them. Airline pilots fly on autopilot most of the time and still train to fly by hand, because they are the backup when it fails. This curriculum is that training for software.
Read the paper: Ironies of Automation (Lisanne Bainbridge, Automatica, 1983)
What you can now learn more shallowly
- Syntax and language trivia.
- Agents write valid code in any mainstream language. The time you used to spend memorizing grammar is better spent reading code fluently and knowing what it does at run time.
- Framework and library API recall.
- Exact function names and options can be looked up or generated. Knowing what a framework does underneath matters more, and it is also how you spot an API that does not exist.
- Boilerplate and scaffolding.
- Project setup, CRUD handlers, configuration and glue code are cheap to generate and easy to check against a working example. Save your attention for the code that encodes business rules.
- Hand-writing standard algorithms.
- You will rarely implement a balanced tree or a sort yourself, but you still need to know what each one costs and when to choose it.
- Mechanical translation and upgrades.
- Porting between languages, library versions or frameworks is mostly mechanical. What stays with you is knowing where their behavior differs, such as integer overflow, async semantics and time handling.