Course 1
Welcome. This is where you begin reading the code an AI writes for you. You do not need to arrive knowing Python. I will introduce the language alongside the tools that let you run it, inspect a change and check a result.
Stage 1 sets the wider direction. Here, your first job is smaller: understand one piece of code well enough to say what it should do, predict what it will do and recognise a result that is wrong.
Begin with the language, then follow it into a solution
The opening chapters follow one Python tree:
| Start here | What you will learn | What you should be able to check |
|---|---|---|
| Chapter 1: Python and Roots | Basic Python, the terminal, Git, dependencies, HTTP, JSON and configuration | A small function, a proposed change, a file operation and a test result |
| Chapter 2: Python and Branches | Intermediate Python, a local MCP server and a LangChain workflow | How data moves through a framework and whether a tool does only its stated job |
Python is the stem. Its roots are the supporting tools and ideas. Its branches are technical areas where Python is used, such as building an MCP server or a LangChain workflow. The solution is the useful thing you make with them: a book assistant, for example, that finds a published lesson and returns its correct title.
The first chapter has seven lessons, alternating Python and a root. The second chapter has eight lessons because its topics need those separate explanations. A lesson may contain Parts when one idea needs a little more space. Read those Parts in order; they belong to the same lesson.
These are the opening chapters of Course 1. They do not stand for the whole course or replace its later web and agent topics.
The wider course, beyond the opening chapters
The opening Python chapters are available now. The rest of the course follows this working module outline; its later lessons are still being developed.
| Module | What it brings together |
|---|---|
| Python: read, verify and connect tools | Python, the terminal, Git, specifications and tests, then applications in MCP and LangChain |
| Python and SQL: build services that keep data | A Python backend, clear request and response rules, databases and access control |
| HTML, CSS and JavaScript: build interfaces people can use | Web pages, browser behaviour, accessibility and the connection to the Python backend |
| Python: build agents that use knowledge | Model-backed workflows, finding source material, preserving information between steps and testing agent behaviour |
| DevOps, deployment and cloud: put a solution into service | Releasing the connected service, protecting its configuration and data, watching for failure and recovering |
Each module joins its main subject, the tools beneath it and an application. This is a grouping of the curriculum, not a fixed list of future chapters. Basic permissions, secrets and recovery appear before they are needed for real use.
The intended depths are 1.3 for Python, JavaScript and supporting tools; 1.0 for the first use of TypeScript, Node.js, React and Next.js; 1.5 for agent frameworks, MCP and deployment; and 2.0 for specifications, tests and directing coding agents. The Stage 1 overview explains what those values mean.
Keep your part of the work visible
You will meet this sequence throughout the lessons:
- State the behaviour you want, including what should happen when an input is wrong.
- Ask the AI to produce or explain a small change.
- Predict the result before the code runs.
- Compare the real result with your prediction, then investigate a difference.
- Explain why you would accept the change, or what still needs fixing.
That is the practical use of the 10–80–10 approach here: you direct, the AI performs much of the execution, and you independently verify. It is not a rule for dividing reading time. A test written by the same AI is useful evidence, but it does not decide what correct means for you.
The Python lessons aim at reading common code and finding clear mistakes. The framework lessons go far enough to identify their main pieces and follow a complete local run. You will not be asked to memorise every method or type a framework from memory.
Give each lesson a fair attempt
Keep the example in view while you learn. When you reach a check, close the explanation and try it yourself before opening the suggested answer. If you cannot explain a result, return to that passage. Completing a page and understanding it are different events.
The worked examples are written for these lessons. Applying the idea to a real solution comes with its own requirement and checks. A book lookup needs accurate public information. A private assistant also needs permission rules. Similar-looking code does not make those responsibilities identical.
The local examples do not require a paid language-model account. Later lessons distinguish a running tool from a model deciding to call it, so you can verify each part without mistaking one for the other.
Download the worked examples when you reach the lessons that run code. Extract the ZIP into a folder and follow its README alongside the lesson. The files match the examples printed here; begin with the explanation before running the later framework files.
Start with Python and Roots. The first lesson gives you a small function you can understand before you install anything new.