Ayşin Sancı

You haven't learned AI yet. Maybe you're a student who wants to test yourself against it, get enough exposure to keep up, or dedicate your life to it. Or maybe you're a solid software engineer, good at what you do, who woke up one morning inside the era of LLMs and felt the ground shift.

Either way, you've probably gone looking for a list. There are thousands of them, written by other people or generated on demand by Claude or ChatGPT or whatever you reach for. And most of the recent ones give you the same first instruction: learn to prompt. Hold onto that, because we'll come back to it at the end. First, the problem with the lists themselves: I've read most of them over the past year, and nearly all make the same two mistakes. They ignore who the learner actually is, and they quietly pretend AI is large language models. It isn't. Autonomous systems, computer vision, IoT, classical ML: generative AI is one bright region of a much larger map. (That map deserves its own post, and it'll get one.)

For the last two or three years I've kept circling the same problem. How do you actually structure AI learning for people who need completely different things from it? I worked it through for two audiences. One was a community of mostly CS students, people building a foundation they don't have yet. The other was a group of working engineers at my company, every level and background, who needed AI to keep real projects moving. I was trying to engineer the right path for each: what to include, what to cut, what order it had to come in. That design problem taught me what every resource list misses. There is no single right order. The path depends entirely on where you're standing and where you're trying to go.

Here's the clearest example I can give you. If you're heading for a PhD, you must understand partial derivatives deeply; they're load-bearing. The neural networks you'll eventually build and reason about are, underneath, partial derivatives at work: backpropagation and gradient descent are calculus, not magic, and you can't push the frontier of something you can't see inside. If you're an engineer who ships every week, learning them first is a waste of your time. Same field, opposite advice, and the only thing that changed was the goal.

So before any resource, any course, any book, let's define who you are.

Three ways to stand

Most lists sort people by job title: student, professional, career-changer. That's the wrong axis, because it produces endless categories that all want roughly the same thing. Sort instead by how deep you need to go, and whether you already have a foundation, and the categories collapse into three.

The Explorer wants enough to not feel lost. To hold a conversation, to use the tools well, to survive the LLM era without pretending to be something they're not. Broad and shallow, and that's a legitimate goal, not a lesser one.
The Builder is serious. A student going for depth, or a professional moving into AI for real (same person, as far as the path is concerned). They have time to invest, and they want to understand why, not just how. They go bottom-up.
The Shipping Engineer already has a foundation and a deadline. They don't need to be taught what a function is. They need just enough of the right layer to ship a specific thing, and they go top-down.

The rest of this post is one path for each. Read the one that's yours. Skim the others if you're curious where the roads diverge, because the divergence is the whole point.

Block 1: The Explorer

If you're here for exposure, the worst thing you can do is start where the serious learners start. Front-loading linear algebra to "learn AI" is how people quit in week two. You don't need the foundations to use the field well; you need them only if you later decide to go deeper. So you follow the same rough path a serious learner does, but with lighter, more applied resources and the heavy maths deferred: do first, understand later, and only as far as your curiosity pulls you.

Start by building something, fast. Python is your entry point, and here's the reassuring truth. Python is basically runnable pseudocode. If you can write a shopping list with a bit of logic in it, you can write Python. Don't study it as a language; use it as a way to make small things happen.

Python, a gentle start Free · written + video · foundation-lite For a clean, modern (Python 3) start, pick one of these and actually finish it:

Automate the Boring Stuff with Python (Al Sweigart), free to read online at automatetheboringstuff.com. This is the one I'd reach for first. It teaches Python by making it do something useful straight away, and of the beginner resources I tried, it's the one that actually stuck.

Harvard CS50P, Introduction to Programming with Python, a superb free video course: YouTube

Udacity, Introduction to Python (free): course

Written companion: Real Python (realpython.com) has excellent free tutorials. Don't try to read the whole site. Go straight to their pandas and data-analysis tracks and skip the deep language-internals material. You're here to work with data, not to customise built-in classes.

Fastest hands-on option: Kaggle Learn micro-courses, short, practical, free, and you're touching real data within the hour. Start with Python, then Pandas for working with data.

Then get intuition for machine learning: the ideas, not the maths. You want to understand what a model is, what training means, why it can be wrong, without deriving anything.

Machine learning, intuition first Free · video · concepts StatQuest (Josh Starmer) is the best thing that exists for this. He explains real ML concepts clearly enough that you don't need the equations to follow along. Watch the ones that sound interesting; ignore the rest. Hands-on: Kaggle's Intro to Machine Learning, the natural next step after their Python and Pandas courses. It won't cover all of ML, but it's a good, practical first taste of building a model. Optional written: Grokking Machine Learning, 2nd ed., Luis Serrano (Manning): manning.com. He explains ML concepts more simply and clearly than almost anyone, with the maths kept gentle, which makes it ideal if you just want to understand how these models work rather than build them from scratch. For an Explorer skimming the shape of the field, this is plenty. Pairs with (free): Serrano's YouTube channel, youtube.com/@SerranoAcademy, same friendly style, same clarity, and a great place to start before spending anything. Go further: it's worth following his work at serrano.academy, where he has fuller courses (some paid). If his explanations click for you, they're worth it, and check for any current student or launch discount before paying full price.

Optional: if the intuition leaves you wanting to actually build something. Some Explorers get a taste of ML and want to go a step further into deep learning without turning it into a maths degree. This is exactly what fast.ai is for.

Practical Deep Learning for Coders, fast.ai (Jeremy Howard) Free · video + code · top-down deep learning course.fast.ai. fast.ai is unapologetically top-down: you build a working deep-learning model in the first lessons and pick up the theory as you go, which fits the Explorer's whole "do first, understand later" spirit. Jeremy Howard is also unusually good at explaining how a language model actually generates text, so by the end LLMs stop feeling like magic. Fair warning: if you enjoy this, you may have quietly become a Builder.

Then meet generative AI properly. This is the part you actually came for, but now you'll understand it as one kind of AI rather than the whole thing.

Generative AI, a grounded intro Free · hands-on · current Kaggle's 5-Day Gen AI course (kaggle.com/learn-guide/5-day-genai) is a great fit here: short, structured, and hands-on, so you actually finish it. It walks you through what LLMs are and how to use them, and it's the same Kaggle you already met in the Python step. (It has run as a timed cohort with live elements, so check whether you're joining a scheduled run or working through the materials at your own pace.)

That's the Explorer's whole path. Maths and statistics are deliberately absent, not because they don't matter, but because for this goal they're a wall you don't need to climb. If you find yourself wanting to know why something works, that curiosity is the signal you've quietly become a Builder. Congratulations. Read on.

Block 2: The Builder

You want depth. That changes everything, because depth means foundations, and foundations have an order: each layer rests on the one below it. The Explorer could skip the maths; you can't, and this is exactly where the partial-derivatives point pays off. If you want to understand this field deeply rather than just use it, the foundations aren't optional overhead. They're the thing.

So the Builder goes bottom-up: maths, then statistics, then Python, then machine learning, then generative AI. Here's each layer, with something to read and something to watch, because the same idea lands differently in prose and in motion.

The maths

Mathematics for Machine Learning, Deisenroth, Faisal & Ong written · foundation Legally downloadable from the authors at mml-book.com (free direct PDF). The place to start if you want to actually understand what's happening under a model instead of just calling .fit(). It covers the linear algebra, calculus, and probability that everything above rests on. It's dense, so don't fight that alone. Pair with: 3Blue1Brown, Essence of Linear Algebra and Essence of Calculus (free · video). Watch these first if maths intimidates you. They build the visual intuition the book assumes you already have, and they're some of the best explanatory videos ever made about anything.

The statistics

A note that saves you money and confusion: the maths book above covers probability, but it is not a statistics course. Probability and statistics overlap but aren't the same. You still need the applied statistical reasoning underneath everything: distributions, inference, what a p-value actually means, how to think about data.

Start with the intuition before anything heavier. StatQuest is where the core ideas finally make sense; just know it's the on-ramp, not the destination.

Statistics fundamentals, StatQuest (Josh Starmer) Free · video · foundation (gentle intro) Josh Starmer's statistics fundamentals playlist is the clearest ground-up explanation of the core ideas you'll find anywhere: YouTube. It builds real intuition, and it's the perfect thing to watch right after the maths book. He also has short companion books on Amazon if you like something to hold, but for building the intuition, the videos are enough.

From that foundation, cross the bridge from statistics into machine learning, and pick up the rigour StatQuest leaves out.

An Introduction to Statistical Learning, James, Witten, Hastie & Tibshirani ("ISL") Free PDF · written + video · the stats-to-ML bridge Worth being precise about what this is: ISL isn't a pure statistics book, it's where statistics and machine learning meet. It teaches the foundational statistical models (regression, classification, resampling, trees, and more) with real rigour. And it is not an easy read, so don't make it your first contact with statistics; come to it once the fundamentals above are solid. Free from the authors at statlearning.com, where you can pick the R or Python edition. Its heavier sibling, The Elements of Statistical Learning, is also free, but it's the deep end: note it exists, come back later, don't start there. Pair with: the authors' own official companion video series, taught by Hastie and Tibshirani themselves: YouTube. Video from the people who wrote the book is about as trustworthy as a pairing gets.

Python

Python, for the Builder Free core, optional paid · written + video · tooling Same reassurance: Python is runnable pseudocode. As a Builder you'll want real fluency with the scientific stack (NumPy, pandas, Matplotlib), not just syntax. Real Python's pandas for Data Science learning path is the cleanest structured route through exactly that, and Kaggle Learn (kaggle.com/learn) gives you repetition on real datasets. You still don't need to master the language before starting ML; you need to be comfortable, not expert.

Level up (optional, and you don't have to go this deep): Fluent Python, 2nd ed. (Luciano Ramalho): Amazon. This is not a beginner book and it's not strictly necessary for ML. But if you want to write genuinely idiomatic, deep Python, this is the one. The door's open; walk through it when the basics are automatic.

One more thing worth saying plainly: the "Python for AI" you actually need is the data stack above plus one modelling library (scikit-learn). You don't need a separate "Python for AI" course, and collecting one is how people end up with ten half-finished tabs.

Machine learning

This is the layer where the field starts to feel real, and here's the good news for your budget: the best-known ML course is free to audit.

Machine Learning Specialization, Andrew Ng (DeepLearning.AI & Stanford, on Coursera) Free to audit · video + code · the ML core Ng's three-course specialization is the standard entry point, and it covers exactly the ground you want: supervised learning, unsupervised learning, and the basics of recommenders and reinforcement learning. coursera.org. You can audit the videos for free and pay only if you want the graded assignments and a certificate. One honest note, because it's widely misremembered: the current specialization is deliberately beginner-friendly and lighter on maths than Ng's original 2012 course. That works in your favour. Because you did Maths for ML first, you'll move through the theory comfortably and can spend your attention on the ideas rather than the notation.

Deep Learning Specialization, Andrew Ng (DeepLearning.AI, on Coursera) Free to audit · video + code · the deeper step This is the natural next move, and the one where your maths foundation really earns its keep: neural networks first, then convolutional and recurrent architectures. More technical than the first specialization, and the right place to go once the ML core feels solid. coursera.org.

Books to sit alongside the courses:

Hands-On Machine Learning (Scikit-Learn & PyTorch edition), Aurélien Géron (O'Reilly): Amazon. The best applied ML book there is: project-first, code-heavy, and this newer edition uses PyTorch, which is the framework most research and a growing share of industry now default to. Pair it with Ng's videos and you get theory and practice at the same time.

Introduction to Machine Learning, Ethem Alpaydin (MIT Press, 4th ed.): Amazon. A rigorous academic reference rather than a tutorial. This was my own reference text back when I first learned this material, and it's the kind of book you dip into for the formal treatment of a method, not the one you read cover to cover first.

And then, see how big this actually is

Before generative AI, one detour that reframes the whole field.

Artificial Intelligence: A Modern Approach, Russell & Norvig ("AIMA") Paid book · written · the map Amazon. The standard, comprehensive AI textbook, and it covers the parts of the field the LLM era tends to skip past: search, logic and knowledge representation, reasoning under uncertainty, reinforcement learning, natural language processing, and intelligent agents. Here's why that matters for you specifically: these aren't a detour away from LLMs, they're the ground LLMs stand on. Modern agents run on search and planning, RLHF is reinforcement learning, and today's language models are the latest chapter of NLP. Work through this and you stop seeing LLMs as magic and start seeing them as the current layer on a deep stack. You don't have to read all of it, but a serious Builder who does will have a foundation for generative AI that most people skip straight past.

Generative AI

Now that you understand the maths and the ML underneath, you can learn generative AI properly rather than as magic. Here are three, tiered by how much time and depth you're after.

Andrej Karpathy's LLM videos (youtube.com/@AndrejKarpathy) Free · video · how LLMs actually work By now you've likely met Karpathy's Neural Networks: Zero to Hero series at the deep-learning stage (he builds a GPT from scratch; it's the technical foundation). Here, reach for his LLM-specific videos: Deep Dive into LLMs like ChatGPT walks the full training stack, pretraining, tokenization, fine-tuning, RLHF, hallucinations, and How I Use LLMs is the practical companion. There's no clearer explanation of what a modern language model is actually doing. Worth trusting, too, because his depth goes back well over a decade: he was the creator and lead instructor of Stanford's CS231n, its pioneering deep learning course on computer vision, years before LLMs made the field famous.

Build a Large Language Model (From Scratch), Sebastian Raschka (Manning) Paid book, free code + video · written · the deep companion Raschka is an established ML researcher and educator, and this is the written counterpart to Karpathy's videos: rigorous, code-first, no hand-waving. His official companion hub ties everything together, the free GitHub code repo (widely starred and used), a free YouTube course, and the book itself. If you're serious about understanding LLMs rather than just calling them, don't skip his work.

The Hundred-Page Language Models Book, Andriy Burkov Paid book · written · the concentrated option For the opposite need: you want the essentials without a doorstop. Burkov is known for compressing a field into its load-bearing ideas, and his hundred-page format is ideal when you want signal fast. Start here if time is tight, go to Raschka when you want the full depth. Amazon

A note for Builders who learn by doing rather than by climbing every foundation in order: fast.ai (course.fast.ai) takes the opposite, top-down approach, getting you to a working deep-learning model fast and filling in the theory afterwards. If the strict bottom-up path frustrates you, fast.ai is a legitimate fast track. Just know you'll circle back for the foundations eventually. One more reason it earns a place here: its NLP material is the natural bridge from classical ML to the generative models we now call LLMs. Before "generative AI" was the phrase, this was NLP, and seeing that lineage is what makes transformers stop feeling like magic.

That's the Builder's road. It's longer than the Explorer's on purpose. The slow path compounds: every layer you actually understand makes the next one faster, and by the end you're not using AI, you're reasoning about it.

Block 3: The Shipping Engineer

You're different from both of the above, and the difference isn't your job title. It's that you already have a foundation and a deadline. You can code. You understand systems. You ship. Sending you bottom-up through linear algebra would be malpractice; you'd waste months learning things you'll use a handful of times, if ever. (Remember the partial derivatives the Builder had to learn? You don't have time for them, and that's the right call. You're an engineer; you engineer your way to the goal with what the problem actually needs.)

So the Shipping Engineer goes top-down and just-in-time. Start from the thing you need to build, drill down only as far as the problem forces you to, and pull in the next layer when you hit a wall. But there's a sensible order to it, three steps, not a scramble.

Step one: the building blocks of LLMs. You don't need to build a language model from scratch, but you do need to know what's happening inside one, tokens, temperature, context windows, why models hallucinate, why they drift. The fastest honest route is Andriy Burkov's Hundred-Page Language Models Book (Amazon) for the concentrated version, or Karpathy's LLM videos if you prefer to watch. And if agents are where you're headed, NVIDIA's Agentic AI Explained is a free, gentle primer on what agentic AI actually is. This is the part people skip and regret, it's what separates shipping a feature from shipping a liability.

Step two: how to ship it. This is where your cloud provider's learning path becomes your real entry point, because it teaches you to build and deploy on the stack you already use. Don't pick a cloud to learn ML; you almost certainly already have one, so start with its path. The vendor courses give you applied summaries, the using version, not the proving version, and they take you from model to deployed service:

AWS (AWS Skill Builder): start light with Cloud Quest: Machine Learning, a gamified intro. Going deeper or chasing the cert? The ML Engineer Associate Learning Plan (with labs) is the hands-on track. For the GenAI step, Cloud Quest: Generative AI Architect. You almost certainly don't need all three; pick by how far you're actually going.

Google Cloud (Cloud Skills Boost): the Machine Learning Engineer path for the ML core, then generative AI in two tiers, the lighter Introduction to Generative AI, or the more technical Generative AI for Developers since you're already an engineer.

Microsoft Azure (Microsoft Learn): start with Azure AI Fundamentals, step up to the Azure AI Engineer Associate (AI-102) for the hands-on cert track, and for generative AI, Get started with AI apps and agents on Azure, which covers RAG and agents directly.

And whichever model you build on, read its maker's own guidance, but understand why this matters, because it's not the throwaway "go read the docs" it looks like. Prompt engineering is real, but it does not transfer. There's no one-size-fits-all prompt across providers, and, the part people underestimate, no one-size-fits-all even across models from the same provider. In practice I've had to rewrite system-prompt wording just because we moved to a newer model from the same vendor: same task, same provider, different behaviour. So the maker's docs aren't a formality; they're where you learn how this specific model actually behaves, and you re-learn it every time the model underneath you changes. Budget for that. A prompt is not a build-once artifact.

Step three: the goal-specific pieces. With the blocks and the platform in place, learn the rest by what you're building, not by topic. The three that come up most:

"I need to ship retrieval over our own documents." The RAG chunk: what embeddings are for, how retrieval augments a prompt, and where it breaks and fails silently. You're done when you can build it and explain how you'd catch it going wrong. Learn it from current provider cookbooks and framework docs (the Anthropic and OpenAI cookbooks, plus your retrieval framework's own guide) rather than a fixed tutorial, this space changes too fast for anything printed. When you're ready to move from a working prototype to serving it at scale, NVIDIA's Deploying RAG Pipelines for Production at Scale is a focused, hands-on option.

"I need an agent that can take actions, not just answer." The agentic chunk: tools, control loops, memory, and above all what to trust the model with versus what to guard. An agent that takes actions can cause damage, so the guardrails aren't optional. Start from the provider agent/tool-use docs, which stay current with the fast-moving patterns; for a structured, hands-on treatment, NVIDIA's Building Agentic AI Applications with LLMs is worth a look.

"I need to know if this thing is actually working." The evaluation chunk, the most under-taught and most valuable, and the line between people who ship responsibly and people who ship and hope. How do you measure quality when there's no simple right answer? How do you catch drift before your users do? The durable idea, whatever tooling you use, is to build a small evaluation set from real failure cases and measure every change against it. For a concrete, hands-on treatment of the RAG-specific version of this, NVIDIA's Evaluating RAG and Semantic Search Systems is a focused option.

Step four: observe it like it's alive, because it is. This is the step conventional engineers underestimate most, and it's where your existing instincts need a twist. You already know how to observe a production system: latency, errors, cost, uptime. In production I've leaned on Datadog for exactly that, and SageMaker for deploying and operating models. But an LLM feature needs a second layer of observation your usual dashboards don't give you. A traditional service is deterministic; an LLM drifts, hallucinates, and degrades in quality while every operational metric stays green. So you're watching two different things at once: is the system healthy (the layer you know), and is the output still good (the layer that's new). Model drift, quality regression, and hallucination don't show up as latency spikes. SageMaker has model-monitoring features built for this, drift detection and the like, and the other clouds have equivalents; AWS's own learning material has good sections on the failure modes to watch for. The tooling landscape here is its own category now (APM platforms extending into LLM monitoring, plus AI-native evaluation tools), and the honest advice is to learn the category and pick for your stack rather than chase a specific product. The point isn't the tool. It's that shipping AI means monitoring behaviour, not just infrastructure.

Go deeper, when you have the time

None of this is needed to ship your first version. If you've worked through the steps above, you already have what you need. But when the fire's out, one book is worth the whole picture:

AI Engineering: Building Applications with Foundation Models, Chip Huyen (O'Reilly): Amazon. Here's the honest read: if you've shipped production systems for years, a good half of this (deployment, monitoring, scaling) is territory you already know. The value is the AI-specific material, foundation-model behaviour, evaluation, RAG, inference optimisation. Don't read it cover to cover; go to the chapters that are new to you. It's also on the O'Reilly platform if you have access, so you can dip in without buying.

The debt is real, and worth naming honestly: going top-down means you'll have gaps. One day a gap will bite. A model behaves strangely and you lack the statistical intuition to know why. That's fine, and here's the useful part: you already know where to go. The gap sends you up into the Builder's foundations from earlier in this post, not out to some new resource. Weak on the stats? Drop into the StatQuest fundamentals and the relevant ISL chapter. Shaky on what's happening inside the model? Back to Maths for ML, or Karpathy building a GPT from scratch. You take one rung, the specific one the problem exposed, then climb back to what you were shipping. You're not avoiding the foundations forever; you're pulling them in exactly when a real problem makes them concrete. That's not laziness, it's engineering your time in production: learning precisely what you need, precisely when you need it. It's how experienced engineers actually work, and it's why the three paths in this post are really one map read from different starting points.

Where this leaves prompt engineering

Remember the instruction we started with, the one most recent lists lead with: learn to prompt. It's not bad advice. Prompt engineering is a real skill and a perfectly reasonable door to walk through. The only trouble is treating it as the whole house. It's one tool you pick up along whichever road is yours, light for the Explorer, deeper for the Builder, sharpest for the Engineer shipping with it daily.

Which is the real point of all this. The first skill isn't prompting, and it isn't any single course on any single list. It's choosing your path deliberately: knowing which of the three you are, and refusing to walk someone else's road because a list told you to.

[Coming next: the map itself. Why AI is so much bigger than large language models, and what lives in the regions nobody's talking about right now.]