Stage 1 — Software and AI Engineering Foundations
Welcome to Stage 1. Stage 0 introduces software and the decisions behind it. Here, you learn to read code, specify changes and check what an AI builds.
You take four courses in order. Within each course, you learn the language together with its supporting tools and the places it is used. Programming, web work and AI are connected throughout.
This page shows the route, the depth of each course and how you will practise. Course 1's opening lessons are available. The later courses have curriculum outlines; their lessons are not available yet.
Four courses, each building on the last
| Order | Focus | What you learn to judge |
|---|---|---|
| Course 1 | Shared foundations: Python, web interfaces, data, agents and a first deployment | What a small piece of software should do, how its parts connect and whether the result matches your specification |
| Course 2 | Deeper Python, databases and agent engineering | How an agent uses tools, retrieves information and keeps track of work; whether it succeeds on meaningful tests |
| Course 3 | Deeper web development | Whether a web interface is usable, accessible, secure and fast, and connects correctly to its Python backend |
| Course 4 | DevOps, deployment and cloud: releasing and operating software | Where a service runs, who may access it, how to detect a failure and how to recover without losing data |
Why this order? Course 1 teaches the shared foundations first. Course 2 deepens the agent side; Course 3 deepens the web side. Course 4 brings their operation together. Basic security, deployment and recovery appear earlier, when first needed; they do not wait until Course 4.
A later course links back to a foundation you have already learned and adds what is new. You do not repeat a complete Git or Python introduction every time another tool uses it.
How the material fits together
Stage → Course → Module → Chapter → Lesson → optional Parts. A module groups work towards one useful outcome. It teaches the main subject, the tools it relies on and an application together. A chapter connects related lessons; a lesson is one continuous read. Parts divide a lesson only when it needs them.
For example, the opening Python work includes reading code, using the terminal and tracking changes. It then follows Python into an MCP server, a program that exposes tools to an AI, and a LangChain workflow, which connects steps in an AI application.
Stage 0 has a simpler structure: courses lead directly into chapters and lessons. Here, modules organise the wider curriculum. The module outlines may change as lessons are written; they are not a promise of a fixed chapter count.
How deep you go
The Thesis explains the depth scale. Its values describe the understanding you need, rather than a score.
| Course | Intended depth |
|---|---|
| 1: languages and tools | Python, JavaScript and supporting tools at 1.3: read common code, predict results and spot obvious mistakes |
| 1: web frameworks | TypeScript, Node.js, React and Next.js begin at 1.0: understand their purpose and judge a visible result |
| 1: agents and deployment | Agent frameworks, MCP and deployment at 1.5: identify the main parts and follow a run |
| 1: directing the work | Specifications, tests and directing coding agents at 2.0: steer and check the work |
| 2 | Python, agent frameworks and databases at 2.0, including LangChain, LangGraph and the OpenAI Agents SDK |
| 3 | The JavaScript family and web-specific development, security and deployment at 2.0 |
| 4 | Shared operations at 2.0, with an introductory Kubernetes and Helm section at 1.5. These tools manage groups of running services; deeper work belongs in Stage 2. |
Python is the backend language throughout. JavaScript and TypeScript serve the web interface. You learn each tool at the first problem it solves.
The AI builds; you direct and verify
Stage 1 uses Spec-Driven Development: you write down the intended behaviour, AI implements it, and you check the implementation against that requirement. You remain responsible for the result.
Course 1 calls its division of responsibility 10–80–10: you direct the work, AI performs most of the research, building and testing, and you independently verify it. Those numbers do not divide your reading time. A test written by the same AI can help you, but it cannot decide what correct means.
Your checks include predicting results, finding bugs, reading a run, choosing a design and writing requirements and tests. Each topic ends in a closed-book check, with the marking criteria shown first and an 80% pass mark. You return to anything you missed. The check asks you to explain and judge, rather than memorise the spelling of code.
The first two real applications of a topic go slowly enough for you to follow and explain each change. As your understanding grows, you can direct larger changes. A working result still needs checks on permissions, private data, failure and recovery before people rely on it.
Give each lesson time to become useful
The book asks for four hours a day, beginning with one lesson and continuing with practice. Read the explanation, make a prediction, then compare it with what actually happens. The last lesson of a chapter brings its ideas together through practice and review.
You are working towards useful software for real people. The next stage takes that responsibility further, into whole solutions, harder failures and deeper specialisations.
Begin with the Course 1 overview. It points to the lessons you can read now.