◆ A hands-on course · free · self-paced
Python for AI Engineers
The Research hub explains AI engineering. This course puts your hands on the keyboard. I wrote it for people who can already read code but want to actually build with LLMs — in the language the whole field is written in.
Fifteen chapters, from the language basics through to a working app you ship yourself. It is free, it is self-paced, and it is honest — I teach the code you actually have to read and trust, and I flag the trade-offs instead of selling you Python as strictly better than what you already know.
◆ Who it’s for
You can read code. You want to build with LLMs.
If loops, functions and async already make sense to you, you don’t need a beginner’s programming course — you need the Python dialect and the culture the AI world runs on. That’s exactly what this is.
◆ What you’ll be able to do
Read any AI codebase
Open a real agent or RAG repo and follow it — the idioms, the SDK calls, the object models — instead of bouncing off unfamiliar Python.
Call LLMs for real
Streaming, structured output with Pydantic, tool use, and retries — the patterns behind every production LLM integration.
Ship a working app
A full capstone: a Customer Feedback Analyzer wiring Streamlit → FastAPI → Gemini → SQLite into one end-to-end build you run yourself.
◆ The curriculum
Fifteen chapters, basics to a shipped app.
Each chapter reads on its own and comes with a downloadable slide deck. Start at the top or jump to what you need — the two capstones at the end tie it all together into working software.
Why Python runs the AI world (and how to think in it as a JS dev)
Why Python won the AI race, the honest trade-offs vs Node, and the mental-model shift that trips JS devs up in week one.
Read chapter →
Environment & tooling: the Python project skeleton (npm → pip/uv mental map)
Virtual envs, pip and uv, pyproject.toml — the Python project skeleton mapped straight onto the npm workflow you already know.
Read chapter →
The core language: values, types, and control flow
Values, types, truthiness and control flow — the everyday syntax you read in every codebase, with the JS gotchas called out.
Read chapter →
Data structures: list, tuple, dict, set (and comprehensions)
list, tuple, dict and set — when to reach for each — plus comprehensions, the idiom that replaces half your map/filter reflexes.
Read chapter →
Functions, arguments, and decorators
Positional vs keyword args, *args/**kwargs, closures, and decorators — the wrapper pattern behind most framework "magic".
Read chapter →
Classes, objects, and dataclasses (OOP the Pythonic way)
Classes, dunder methods and dataclasses — OOP the Pythonic way, and how to read the object models LLM SDKs are built on.
Read chapter →
Modules, the standard library, errors, and context managers
Imports, the standard library, exception handling, and the with-statement — how real Python projects are wired together.
Read chapter →
Type hints and data validation with Pydantic (the GenAI engineer's superpower)
Type hints and Pydantic — the validation layer that turns messy LLM output into typed, trustworthy data. The GenAI superpower.
Read chapter →
Iterators, generators, and async (how LLM streaming and concurrency actually work)
Iterators, generators and async/await — the machinery under LLM streaming and concurrent API calls, demystified.
Read chapter →
Writing (and judging) Pythonic code: idioms, testing, logging, and a review checklist
Idioms, pytest, logging and a concrete review checklist — how to write Python that reads well and judge code that does not.
Read chapter →
The data & HTTP layer you must be able to read (numpy, pandas, httpx)
numpy, pandas and httpx — enough of the data and HTTP layer to read (and trust) the code every AI system leans on.
Read chapter →
Calling LLMs in Python: SDKs, streaming, structured output, tools, retries
Calling models for real: SDKs, streaming, structured output, tool use and retries — the patterns behind every LLM integration.
Read chapter →
Agentic & RAG patterns, serving, and how to read a real agent codebase (capstone)
RAG and agent loops, serving, and a guided read of a real agent codebase — where all the earlier pieces snap together.
Read chapter →
Shipping it: Streamlit UIs, FastAPI from scratch, and SQLite persistence
Streamlit for a quick UI, FastAPI from scratch, and SQLite persistence — the shortest honest path from script to shipped app.
Read chapter →
Capstone II: the Customer Feedback Analyzer (Streamlit → FastAPI → Gemini → SQLite)
The full build: a Customer Feedback Analyzer wiring Streamlit, FastAPI, Gemini and SQLite into one working end-to-end app.
Read chapter →◆ How this fits with the Research hub
The theory and the practice, side by side.
My flagship write-up, The AI Engineering Pipeline, maps the whole field — frameworks, SDKs, the Prompt / Context / Loop trichotomy, evals and agentic security. This course is the other half: the Python you need so that map turns into code you can actually write.
It’s free and it always will be. If it helps and you later need someone to take GenAI from pilot to production — safely, in a regulated setting — that’s the work I do.
Ready? Start at the beginning.
Chapter 01: why Python runs the AI world, and how to retune your instincts from JavaScript.