Course structure, entry tests, personal repository and learning with AI.

Levels, modules and lessons

The course has eight levels, from 0 (Python from scratch) to 7 (production and final project). Each level is divided into modules and each module into lessons like this one. The figure at the top shows the approximate hours of each level: the total is around 750–850 hours.

flowchart TB
  L[Lesson] --> E[Exercises] --> A[Self-assessment]
  A --> M{All clear?}
  M -- yes --> S[Next lesson]
  M -- no --> L
  S -. at the end of the level .-> P[Level project]
  P -. at the end of the course .-> C[Final project]

Every lesson has the same parts:

• Objectives at the start: what you should be able to do when you finish.
• Content with runnable code. All the code in the course has actually been run and the outputs you see are real. The level 0 data are synthetic (generated with a seed) so that you get exactly the same result.
• Exercises with the solution collapsed. Try to solve them before opening it.
• Self-assessment: three to five questions with the answer and the reasoning behind it.
• Key ideas and resources to go deeper.

The levels are cumulative, but you do not have to go through all of them in order. The syllabus proposes four paths depending on your starting point:

Entry tests: when to skip a level

Each level has an explicit prerequisite (on the level's page). To find out whether you can skip it, use its self-assessments as an entry test: go through those of all its lessons without looking at the content. If you answer all of them correctly and understand the reasoning behind each answer, move on to the next level. If you fail the ones in a module, do only that module.

Two warnings. First: level 0 looks dispensable for someone who already programs, but it includes tools that have changed a lot in two years (uv, pandas 3.0, Polars, DuckDB); review at least module 0.5. Second: the self-assessments measure concepts, not fluency. If a question seems easy but you could not write the exercise code without help, do not skip the module.

Your course repository

Everything you write during the course lives in a single Git repository. It starts with a few folders and ends up being your personal framework: the level 1 functions (data download and cleaning) will be used by the level 2 backtest, and both will be used by the level 4 live system.

The recommended structure, created with pathlib (covered in module 0.4; here only the result matters):

import tempfile
from pathlib import Path

raiz = Path(tempfile.mkdtemp()) / "ppt-curso"
carpetas = ["datos/brutos", "datos/procesados", "notebooks", "src/ppt",
            "tests", "informes"]
for carpeta in carpetas:
    (raiz / carpeta).mkdir(parents=True)
(raiz / "src/ppt/__init__.py").touch()
(raiz / "README.md").write_text("# My course repository\n")
ignorar = [".venv/", ".env", "datos/brutos/", "__pycache__/"]
(raiz / ".gitignore").write_text("\n".join(ignorar) + "\n")

for ruta in sorted(raiz.rglob("*")):
    nivel = len(ruta.relative_to(raiz).parts) - 1
    print("    " * nivel + ruta.name + ("/" if ruta.is_dir() else ""))

.gitignore
README.md
datos/
    brutos/
    procesados/
informes/
notebooks/
src/
    ppt/
        __init__.py
tests/

• datos/brutos/ (raw data): what you download, as is. It is not versioned (it can be large and sometimes its license does not allow redistribution); it can be downloaded again.
• datos/procesados/ (processed data): clean data, in Parquet from level 1 on.
• notebooks/: exploration. Whatever works in a notebook is moved to src/.
• src/ppt/: your reusable code, as a Python package.
• tests/: tests with pytest (lesson 0.4.5).
• informes/ (reports): the reports the projects generate.

In practice it is not created with Python, but with uv and Git from the terminal. You will do it in module 0.2; these are the commands, so that you recognize them:

uv init ppt-curso          # project with pyproject.toml (lesson 0.2.2)
cd ppt-curso
git init                   # repository (lesson 0.2.5)
git add .
git commit -m "Initial course structure"

Learning with AI: the course rules

Coding assistants (Copilot, Claude Code, Codex, Cursor) write in seconds functions that take a beginner an hour. That makes them very useful for someone who can judge the result and dangerous for someone who cannot: the code they generate is plausible, and plausible is not the same as correct. In trading, a plausible mistake (a signal shifted one day too many or too few, a forgotten cost) produces a pretty backtest and a strategy that loses money.

That is why the course has three rules:

1. Level 0 without an assistant. Write and read the code of this level yourself. You can ask a chat conceptual questions, but do not ask for the code of the exercises.
2. Afterwards, the AI proposes and you decide. From level 1 on, use assistants with a fixed workflow: first you write the test the code must pass, then you ask for the code, read it in full, run the tests and only then commit.
3. Nothing sensitive in the prompt. No keys, no data whose license does not allow sharing it, no personal data.

flowchart TB
  T[You write the test] --> P[You ask for the code] --> L[You read it in full]
  L --> X{Do the tests pass?}
  X -- no --> P
  X -- yes --> C[Commit]

Lesson 0.2.6 returns to assistants in more detail, and level 6 devotes an entire module to using them as a research copilot.

Exercises

1. Choose your path. Using the paths figure and each level's page, write in your repository's README.md (or in a note, if you do not have it yet) which level you start at, which levels you will do in full and which ones only in part.

2. Write your repository's .gitignore. Besides what the lesson covers, what other things should not be versioned in a trading project?

3. Ask an AI assistant for a Python function that computes the daily return of a price series, without giving it any more context. Before reading the answer, write three questions whose answer should be in the code.