This is not an artificial intelligence course and I am recommending it anyway, because the single most common weakness I see in self taught AI engineers is not maths and it is not PyTorch, it is computer science. People who came in through a fast track machine learning path can build and fine tune models but cannot reason about the cost of what they wrote, cannot spot that their retrieval loop is doing a linear scan over a hundred thousand documents, and have no vocabulary for why one data structure is the right answer and another is not. 6.006 fixes that. The Spring 2020 OpenCourseWare version is the one to use.
It is taught by Erik Demaine, Jason Ku and Justin Solomon, and it comes with full lecture video, full written lecture notes, recitation notes and problem session recordings. That last item matters more than people expect. The problem sessions are where the instructors work through the kind of problem you will actually be stuck on, and having them recorded closes most of the gap between watching a course and taking one. Demaine in particular is one of the small number of lecturers whose recordings are better than most people's live classes.
He explains the intuition, then the formalism, then why the formalism was necessary, in that order, and he does not skip the step where he tells you what a technique is for. The course structure moves from computation and asymptotic analysis into data structures, then sorting, then graphs and shortest paths, then dynamic programming, then complexity. The organising theme is reduction: you learn to recognise that a new problem is an old problem wearing different clothes, and to reduce it accordingly. That habit is worth more than any individual algorithm you memorise.
The dynamic programming section is the one that changes people. MIT teaches it through a consistent framework of subproblems, relations, topological order, base cases and the original problem, and once you have that scaffold, dynamic programming stops being the mysterious topic everyone dreads. Where this course will hurt is if your mathematical foundation is thin. It assumes discrete mathematics, it assumes you can follow and produce a correctness argument, and it moves quickly.
If you have never written a proof, expect the first three weeks to be uncomfortable. That discomfort is the course working, but you should know it is coming. The other honest limitation is that solutions to problem sets are not fully released, which means self study involves a degree of grading yourself. In practice this is manageable because the notes are so complete, but a study partner makes an enormous difference.
There is also very little implementation work. Python appears, but this is a course about reasoning rather than about building, so pair it with actual coding practice if that is what you need. For AI specifically, the payoff is indirect but real. Vector search, graph traversal in RAG systems, batching and scheduling, tokenisation, beam search, caching strategy, all of it sits on the material in this course.
The people who debug production ML systems well are almost always the ones who understand the underlying computation. My 4.6 is close to as high as I give anything, and 6.006 earns it by being free, complete, superbly taught and permanently useful. It is not the course to take if you want to build a chatbot this month. It is the course to take if you intend to still be technically credible in ten years.