Building Software
Sections

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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  1. Who this course is for6 min
  2. How this course works7 min
  3. Reading the code in this course10 min

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.

  1. Articulating the Ideal StateCore 1
  2. Framing the ProblemDepth: do
  3. Requirements and Acceptance CriteriaCore 2
  4. Domain Modeling and InvariantsDepth: do
  5. Decisions: Recording Why, Inside the Living ArtifactDepth: do

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.

  1. Tests as Executable SpecificationsCore 3
  2. Engineering Robust TestsCore 4
  3. Property-Based Testing and Test QualityDepth: do
  4. Continuous Testing and Fast FeedbackCore 5
  5. Evals: Measuring Any Output Against Its CriteriaCore 6
  6. The Loop: Build, Evaluate, IterateCore 7

3The Machine

How Code Actually Runs

From source code down to silicon and out across the network.

  1. Hardware and the Operating SystemDepth: explain
  2. Languages, Compilers and RuntimesCore 8
  3. Representing Numbers, Text and TimeCore 9
  4. Networks and ProtocolsDepth: explain

4Math and Algorithms

Enough logic, complexity, statistics and estimation to check a claim without asking another model.

  1. Logic and Discrete MathDepth: explain
  2. Algorithms, Data Structures and ComplexityCore 10
  3. Probability and StatisticsDepth: explain
  4. Back-of-the-Envelope EstimationDepth: do

5State

Data, Concurrency and Distribution

The hardest bugs live where data is stored, shared or spread across machines.

  1. Data Modeling and DatabasesCore 11
  2. Transactions and ConsistencyCore 12
  3. Concurrency and Race ConditionsDepth: explain
  4. Distributed Systems and Partial FailureCore 13

6Design

Structuring Systems That Stay Understandable

Structure is what lets a system keep changing without breaking.

  1. Managing ComplexityDepth: do
  2. Components and ArchitectureDepth: explain
  3. Interfaces and APIsDepth: do
  4. Error Handling and Failure PathsCore 14
  5. Where Logic Meets the DatabaseCore 15
  6. Frontend and BackendDepth: explain

7Operations

Running Software in Reality

Seeing what production is doing and changing it without betting the system on each release.

  1. DebuggingCore 16
  2. ObservabilityCore 17
  3. Reliability, Redundancy and RecoveryDepth: do
  4. Shipping Change SafelyCore 18
  5. Performance and CapacityDepth: do

8Security

Boundaries, Data and Trust

Know what is sensitive, where the boundaries are, and who is allowed to do what.

  1. Security Boundaries and Threat ModelingDepth: do
  2. Authentication and AuthorizationCore 19
  3. Sensitive Data and SecretsCore 20
  4. Protecting Data in Transit and at RestDepth: explain
  5. Untrusted Input and InjectionCore 21
  6. 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.

  1. How Agents Work and How They FailCore 22
  2. Telling Agents What, Not HowCore 23
  3. Your Harness: Standing Context Under the Bitter LessonDepth: do
  4. Reading What Agents Built: Understanding and Risk-Based ReviewCore 24
  5. Orchestration, Permissions and GuardrailsDepth: explain
  6. 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.