Skip to main content
Text ready — video coming soon

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 hereWhat you will learnWhat you should be able to check
Chapter 1: Python and RootsBasic Python, the terminal, Git, dependencies, HTTP, JSON and configurationA small function, a proposed change, a file operation and a test result
Chapter 2: Python and BranchesIntermediate Python, a local MCP server and a LangChain workflowHow 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.

ModuleWhat it brings together
Python: read, verify and connect toolsPython, the terminal, Git, specifications and tests, then applications in MCP and LangChain
Python and SQL: build services that keep dataA Python backend, clear request and response rules, databases and access control
HTML, CSS and JavaScript: build interfaces people can useWeb pages, browser behaviour, accessibility and the connection to the Python backend
Python: build agents that use knowledgeModel-backed workflows, finding source material, preserving information between steps and testing agent behaviour
DevOps, deployment and cloud: put a solution into serviceReleasing 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:

  1. State the behaviour you want, including what should happen when an input is wrong.
  2. Ask the AI to produce or explain a small change.
  3. Predict the result before the code runs.
  4. Compare the real result with your prediction, then investigate a difference.
  5. 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.