School of AI: four years and 300+ students in
We started School of AI in 2020 as a free evening meetup in Tbilisi. It became a TSU master's track and shipped over 300 students through it. Here's what we learned.
In 2020, the three of us — Levan, Anzor, and Sandro — started running a free evening course on machine learning out of MaxinAI’s Tbilisi office. We called it School of AI. The plan was small: get whoever showed up through the math foundations, then through the classical ML curriculum, then into deep learning. No tuition, no certificates, no funding. Just a whiteboard and a Colab tab.
Four years later it’s still running, the notebooks are still public, and more than 300 students have come through some version of it. This is a write-up of what worked, what we got wrong, and how a free meetup ended up being taught as a master’s-level course at Tbilisi State University.
Why we started it
In 2020 the Georgian ML talent pool was thin. We were already running MaxinAI as an AI factory and the bottleneck on our applied-AI work wasn’t compute or contracts — it was people. Hiring junior engineers who could read a paper and prototype a model was hard, and the local universities were a year or two behind on the practical side of the field.
The cheap thing to do would have been to write a hiring page. The actually-useful thing was to teach a course and see who emerged from it. So we did. The first cohort met weekly in our office, free, open to anyone who could solve a small admissions problem set in Python.
The early curriculum was thin and ambitious — those notebooks live in maxin_ai_meetings/ and you can still see the original school_of_ai_presentation.ipynb deck and the first lectures on linear regression, logistic regression, and overfitting.
What we ended up teaching
The thesis of the course never changed: build the math floor first, then build models on top of it. We watch a lot of self-taught ML practitioners hit a ceiling around the time backprop stops being magic, and our read is that the ceiling is almost always linear algebra and calculus, not Python or PyTorch.
The 23-lecture syllabus that crystallized over the first two cohorts, in order:
- Linear Algebra (1 + 2)
- Calculus (1 + 2)
- Probability
- Statistics & Information Theory
- Machine Learning Intro
- Workshop 1: car-price + heart-disease prediction (regression / classification)
- Regularization
- SVMs
- Naive Bayes
- Trees & Ensembles
- Workshop 2: Sloan Digital Sky Survey classification (real astrophysics data)
- Deep Neural Networks
- Workshop 3: DNN implementation from scratch in NumPy
- Unsupervised ML
- Optimization Methods
- Segmentation
- Object Detection
- Autoencoders & GANs
- NLP intro
- Workshop 7: question-answering with spaCy + NMSLIB, aspect-based sentiment analysis
- Deep Learning for NLP & Sequence Modelling
Two design choices we’d defend hard:
The math is taught with code, not LaTeX. Every lecture is a Jupyter notebook. The proof of ∂L/∂W for a two-layer MLP doesn’t live in a textbook — it lives in a cell where you compute the gradient analytically, then check it against torch.autograd, and watch them agree to seven decimal places. Math becomes something the laptop can confirm.
Workshops are full datasets, not toy ones. Heart disease (UCI), SDSS galaxy classification, COCO subsets for detection. The first time someone trains on a real dataset and watches their accuracy plateau three points below the leaderboard, they learn more about ML practice than any number of make_classification calls would teach them.
The TSU partnership
In the 2022–2023 academic year, the course migrated into Tbilisi State University’s master’s program. You can see the dated cohorts in the repo:
tsu_master_2022_2023/tsu_master_2023_2024/tsu_master_2024_2025/tsu_master_2025_2026/(in progress)
The university version trades some of the open-meetup energy for accreditation and rigor. We added mid-terms (mid_terms.ipynb), a final exam (final_exam_sm.ipynb), and structured the workshops around the same ML cycle every year — linear regression, logistic regression / LDA / QDA / Naive Bayes, resampling methods, model selection and regularization, beyond-linearity, trees and boosting, SVMs, PCA and clustering.
The MaxinAI evening cohort still runs in parallel for working engineers. Same materials, different audience.
What changed over the cohorts
The curriculum is a fossil record of what changed in applied ML between 2020 and 2024. A few additions worth calling out:
Detection toolkit churn. The original detection lecture was Faster R-CNN by hand. By 2025 we had workshop-11-03-2025-detect-mmdetect.ipynb, workshop-11-03-2025-detect-huggingface.ipynb, and a HuggingFace training notebook side by side, because which framework a junior engineer should reach for is now the more interesting question than the underlying architecture.
Self-supervised representation learning got its own arc. It’s now four notebooks deep: additional_workshop_representation_learning.ipynb, then _2, then _3, plus self_supervised_learning_for_computer_vision.ipynb and lecture_18_03_2025_augmentations_transfer_self_supervised_representation_learning.ipynb. SSL went from a footnote in the autoencoder lecture to one of the load-bearing chapters of the course.
Transformers showed up. additional_2_self_attention.ipynb and dert_transformer_based_object_detection.ipynb are recent additions; in 2020 we taught sequence modelling with LSTMs and a wave to attention at the end. Now attention is the spine.
What didn’t change: the math floor in lectures 1–6 is almost identical to the original 2020 version. Linear algebra and probability haven’t been rewritten by deep learning. Students who skip these lectures regret it within a month.
What 300 students got us
The honest accounting:
- Hires. A non-trivial fraction of the engineers who’ve shipped MaxinAI client work over the last four years came through School of AI first. We’ve stopped tracking the exact number because it stopped being meaningful — the answer is “a lot of them.”
- Network effects. Alumni teach later cohorts. People who took the course in 2020 ran sessions in 2023. The course got better because the people running it had been on the other side of the desk.
- A signal. Showing up to a free 23-week ML course on weekday evenings is a strong filter. It correlates with the thing we actually care about — capacity to grind through unfamiliar material — better than any CV does.
- Curriculum forcing function. We had to know the field well enough to teach it. Anyone who has tried to lecture a room of smart skeptical engineers on something they half-understand can tell you what that does to the depth of your own reading.
What we’d do differently
A few things we got wrong, in case it helps anyone running a similar program:
The first version had no admissions filter. Cohort 1 had a wide ability range, and the math lectures were brutal for the lower end and slow for the upper end. We added a Python-and-math screening problem set in cohort 2 and the dynamic improved instantly. Some filter, even a light one, is kinder to everyone in the room than no filter.
We under-invested in office hours. The lectures were good, the workshops were good, but the between-class support was ad-hoc. The students who succeeded were the ones with someone they could DM at 11 PM about a shape mismatch. Codifying that — pairing every student with an alum mentor — is something we wish we’d done from year one.
We taught too many architectures, too early. An early version of the course covered ResNet, U-Net, Faster R-CNN, BERT, and GANs. Students could recognize the diagrams; few could rebuild any of them. In later cohorts we cut the architecture zoo by half and spent the recovered time on one architecture per family, implemented from a blank notebook. Comprehension rose; recall dropped; we’d make that trade again every time.
The notebooks are messy. Look at the repo — there are _new, _complete, _fixed, _fixed_new suffixes everywhere. That’s what years of evening-class iteration looks like, and we’ve never made time to clean it up. If we were starting today we’d impose a stricter lecture_NN/ folder structure and version notebooks rather than dating them. We’ll get there eventually.
What we’re doing in 2025–2026
The current TSU cohort is using the tsu_master_2025_2026/ materials. We’re rewriting the workshops in-place rather than the lectures — practical tooling moves faster than the math. The big question we’re sitting with for next year: how much of the course should be teaching how to drive an LLM vs. teaching what’s underneath one? The honest answer is probably “more of both, with less of something else,” and we haven’t figured out what to drop yet.
If you’re a student looking to start: the repo is public, the notebooks run on Colab, and the syllabus in the README is the right reading order. Lectures 1–6 first. Skip them at your peril.
If you’re an engineering org thinking about running a free training program and wondering whether it’s worth it: ours has paid for itself many times over, and the second-order effects — the alumni network, the curriculum-as-forcing-function, the credibility — are bigger than the first-order ones. Four years in, we’d start it again tomorrow.