Learning AI: what to study first and the four things to skip

The question behind most searches for AI for learning is really an ordering question. There are more free courses than anyone can finish, and they quietly contradict each other about what comes first. The short answer: start at the layer you can ship from, then learn the mechanism underneath it, and rebuild the internals by hand only if the job asks. Plenty of people invert that, open a linear algebra textbook in week one, and stop in week three.

This piece is about sequence, not about hiring. Our companion guide on how to learn artificial intelligence covers what the job postings ask for and what the certificates cost. What follows is curriculum order, and the evidence for it comes from the courses themselves. Every serious course publishes a prerequisites page, and those pages are the only public statement of what each step assumes you already know.

The order that works, in three phases

Phase one is the application layer, because it’s the only layer where you can build something that works in an afternoon. You write prompts, you wire up retrieval so a model can read your documents, and you measure whether the output got better. Nothing here requires calculus. Our breakdown of prompting vs RAG vs fine-tuning is the decision you’ll make over and over in this phase, so it’s worth learning early rather than late.

Phase two is mechanism. That means training a small model end to end, so the words you have been using loosely acquire referents: gradient, loss, embedding, attention, token. Google’s Machine Learning Crash Course and the Machine Learning Specialization on Coursera both sit here, and so does fast.ai’s Practical Deep Learning for Coders.

Phase three is internals, which most people never need. It’s where you implement a tokeniser, an optimiser and an attention block from scratch, and where you learn why a training run falls over at hour nine. The catch is that phase three is the phase every reading list puts first, because it’s the one that looks like real study.

Phase	What you can build at the end	One resource that fits	Stated time
1. Application	A retrieval app with an eval set you trust	Anthropic’s prompt engineering docs	Not stated
2. Mechanism	A trained classifier and a fine-tuned language model	fast.ai part 1, or the Coursera specialization	9 lessons of about 90 minutes, or 95 hours
3. Internals	A transformer, tokeniser and optimiser written by you	Neural Networks: Zero to Hero, then CS336	8 lectures, then a full Stanford quarter

What the entry courses actually assume you know

The maths anxiety around learning about AI survives because nobody reads the prerequisites page. Google’s crash course states that it “does not presume or require any prior knowledge in machine learning”, and asks only that you’re comfortable with “variables, linear equations, graphs of functions, histograms, and statistical means”. Calculus appears on that page under a heading that says, in parentheses, “optional, for advanced topics”. Even there, the page adds that on derivatives “you won’t have to actually calculate derivatives”.

fast.ai goes further, and puts the claim in a single sentence.

The only prerequisite is that you know how to code (a year of experience is enough), preferably in Python, and that you have at least followed a high school math course.

Practical Deep Learning for Coders, course.fast.ai

MIT’s 6.S191 asks for slightly more and still not much: its FAQ expects “very elementary knowledge of linear algebra and calculus”, specified as multiplying matrices, taking derivatives and applying the chain rule. The same page says experience in Python is “helpful but not necessary”. Andrej Karpathy’s first lecture in Neural Networks: Zero to Hero assumes “basic knowledge of Python and a vague recollection of calculus from high school”, which is about as low as a from-scratch backpropagation course can set the bar.

But compare that with Stanford’s CS336, and the gap is the whole argument for ordering. CS336 wants proficiency in Python, strong familiarity with PyTorch, basic systems concepts like the memory hierarchy, college calculus and linear algebra, and prior deep learning experience. That’s four courses of prerequisite stacked into one line.

Course	Maths it asks for	Coding it asks for	Cost as listed
Google ML Crash Course	Variables, linear equations, graphs, histograms, means. Calculus marked optional	“You should be a good programmer”, Python preferred	Free, exercises run in Colab
fast.ai Practical Deep Learning part 1	A high school maths course	About a year of coding, preferably Python	Free
MIT 6.S191	Matrix multiplication, derivatives, chain rule	Python “helpful but not necessary”	Free online, lectures weekly
DeepLearning.AI Machine Learning Specialization	High school level maths	Basic coding: loops, functions, conditionals	Coursera subscription at $49 a month
Hugging Face LLM Course	Not stated	“A good knowledge of Python”	“Completely free and without ads”
Stanford CS336	College calculus, linear algebra, probability	Python proficiency plus PyTorch and systems	Stanford enrolment, materials public

One more signal sits in the Hugging Face LLM course, which is explicit about where it belongs in a sequence. It says it “is better taken after an introductory deep learning course, such as fast.ai’s Practical Deep Learning for Coders or one of the programs developed by DeepLearning.AI”. Courses rarely name their predecessor that plainly, and when one does, the ordering question answers itself.

Four things you can skip on the first pass

The maths-first detour. A semester of linear algebra before your first model is time spent on notation you can’t yet attach to anything. Three of the four entry courses above ask for high school maths or less, which is the clearest possible statement that the maths can arrive alongside the code rather than ahead of it.

Writing a transformer from scratch in month one. It’s a genuinely good exercise, and it’s the seventh lecture in Karpathy’s series, not the first. He recommends viewers “watch the earlier makemore videos to get comfortable with the autoregressive language modeling framework and basics of tensors and PyTorch nn” before attempting it. Skipping to the GPT video is the most common way people burn a weekend and learn a syntax rather than a concept.

Reading the foundational papers early. Attention Is All You Need, submitted by Vaswani and seven co-authors on 12 June 2017, reports 28.4 BLEU on the WMT 2014 English to German task, and a single-model 41.8 BLEU on English to French after training for three and a half days on eight GPUs. Those numbers mean something once you’ve trained a model and watched a loss curve, because you’ve seen what a number like that costs. Before that, the paper reads as vocabulary, and the vocabulary is what you’re trying to acquire.

Collecting courses in parallel. The Coursera specialization alone lists 33, 34 and 28 hours across its three courses, and describes itself as “2 months at 10 hours a week”. The Hugging Face course budgets a chapter a week across twelve chapters, at roughly six to eight hours each. Running two of those at once turns a finishable plan into an abandoned one, and neither certificate is worth anything half done.

Evaluation comes earlier than the reading lists put it

The skill that moves fastest from beginner to useful is measurement, and almost every syllabus buries it. Anthropic’s prompt engineering overview puts it in the first lines of the page, before any technique. The guide assumes you already have “a clear definition of the success criteria for your use case” and “some ways to empirically test against those criteria”. If you don’t, the page says to “spend time establishing that first”.

That instruction is doing more work than it looks. Without an eval set, you can’t tell whether a prompt change helped, which means you can’t tell whether fine-tuning would help either. The result is that people fine-tune to fix problems a better prompt would have solved, and they never find out. It’s also why public benchmark scores are a poor substitute for a test set built from your own inputs.

Evaluation is also the part of AI and learning that transfers cleanly, because it’s a habit rather than a tool. A tokeniser you wrote in 2026 ages with the architecture. The habit of writing twenty test cases before changing anything does not.

Using AI for learning has one specific failure mode

Learning in AI now usually involves asking a model to explain the thing you’re learning, which works until it doesn’t. Stack Overflow’s 2025 Developer Survey found that 84% of respondents are using or planning to use AI tools in their development process, up from 76% the year before, with 51% of professional developers using them daily. Trust ran the other way. More developers actively distrust the accuracy of AI tools (46%) than trust it (33%), and only 3% report “highly trusting” the output.

The biggest single frustration, cited by 66% of developers, is dealing with AI solutions that are almost right, but not quite.

2025 Stack Overflow Developer Survey

“Almost right, but not quite” is a tolerable failure when you can check the answer. It’s a bad one when you’re learning, because you still have no way to tell the almost from the right. The same survey asked when developers would still want a human, and the answers line up with exactly that problem: 75.3% said when they don’t trust the answer, 61.3% when they want to fully understand something, and 58.1% when they want to learn best practices.

Which suggests a narrow role rather than no role. A model is good at rephrasing an explanation you half understood, at generating practice problems, and at reading an error message you’ve never seen. It’s weaker as your only source on a topic where you can’t yet spot a confident error. The survey also found 45% of developers say debugging AI-generated code takes more time, and that penalty is worse when the code is the lesson.

When the from-scratch track earns its time

Phase three isn’t optional for everyone. If you want to work on pretraining, inference optimisation or model architecture, you need the internals, and Stanford’s CS336 is the most honest public description of what that costs. Its five assignments cover a tokeniser, model architecture and optimiser written from scratch, a Triton implementation of FlashAttention2 plus distributed training, fitting a scaling law, turning raw Common Crawl dumps into pretraining data, and alignment with reinforcement learning. Stanford lists it as a 5-unit class.

The prerequisites page does not soften the workload.

Unlike most other AI classes, students will be given minimal scaffolding. The amount of code you will write will be at least an order of magnitude greater than for other classes.

CS336 Language Modeling from Scratch, Stanford, Spring 2025

But a gentler on-ramp to the same territory is Neural Networks: Zero to Hero, eight lectures that go from a scalar autograd engine to a GPT and then to the byte pair encoding tokeniser behind it. That last lecture is the one that makes tokenisation stop being weird. fast.ai’s part 2, billed on the site as a video course of more than 30 hours, covers the same depth from a different angle by building up to Stable Diffusion.

Worth saying plainly: none of this is required to be employed doing useful work with models. It’s required to change how they’re built.

What ages fastest, and what to do about it

Still, course material dates in an obvious place and a hidden one. The obvious one is the library API. The hidden one is the task. fast.ai’s part 1 was recorded in 2022 at the University of Queensland, and its nine lessons still teach the right habits, but the worked problems come from a period before instruction-tuned chat models were the default interface. That doesn’t make the course wrong. It means the deployment chapter is describing a world with fewer hosted options than you have.

The Hugging Face LLM Course is the counterweight, because it tracks the current tooling and now runs to twelve chapters, with the last three covering fine-tuning, dataset curation and reasoning models. So pairing a stable course for concepts with a maintained one for tooling costs less than chasing whichever course launched most recently.

Live courses are a third option. MIT’s 6.S191 ran its 2026 online edition from 30 March to 25 May 2026, one lecture every Monday at 10am ET, with three software labs on music generation, facial detection systems and fine-tuning a language model. A course that re-records annually carries less staleness risk than one that doesn’t, though it also gives you less time to catch up.

What would change this order

Three things would, so it’s worth naming them. The first is your target job. If you’re aiming at a research role, the internals move to the front and the application layer becomes the thing you skip, because a lab interview tests the maths and not your retrieval pipeline. The ordering here is built for the far larger group building things on top of models.

Then there’s your starting point, which changes the maths bill. Somebody with a quantitative degree has already paid the phase two maths cost, so going straight to Karpathy or CS336 is reasonable. The prerequisites tables above are the test, not a general rule about beginners.

The third thing is the tooling, and that’s the one nobody controls. Every argument for skipping the internals rests on the application layer staying stable enough to build on, and that’s an observation about 2026, not a law. If the abstractions get leakier, phase three moves up. The signal to watch is simple: when you can no longer fix a production problem without knowing what the model is doing internally, the order in this piece has expired. Until then, the evidence that the courses themselves publish points one way, and it isn’t the way the reading lists are sorted.

Sources checked on 21 September 2026: the 2025 Stack Overflow Developer Survey AI results, MIT 6.S191, and the course pages linked above.