The Real AI Roadmap — Using ChatGPT every day doesn't mean you know AI. If you just want to use AI well inside the job you already have, that's four to eight weeks and none of what follows. But if you want to build AI systems, there's an order: Python, then object-oriented programming, then data structures, then machine learning, then deep learning, then LLMs, and only then RAG and agents. Roughly nine to twelve months at eight hours a week. You don't need a PhD, a CS degree, or 500 LeetCode problems — you need to build something at every stage instead of just watching. Tools change; today ChatGPT, tomorrow Claude, then whatever launches next. Fundamentals don't. Start with CS50P, today.

The Real AI Roadmap

What to learn, what to skip, and what to build — in order.

by @techwithgul

---

Using an AI tool and understanding AI are two different things.

Both are valuable. They are not the same skill. And most "AI roadmaps" online are a list of buzzwords with no order, no timeline, and no honest answer to "do I actually need this part?"

This is the roadmap I'd hand you if you sat across from me and asked where to start.

Who wrote this: I'm Gul. Master's in AI from Leibniz University Hannover, 7+ years building AI products and leading AI engineering teams. I was learning programming, algorithms and machine learning long before generative AI became a trend — which mostly means I've already wasted the time you're about to save.

---

PART I — BEFORE YOU START

1. Pick your track

This is the most important section here. Most people fail this roadmap because they started on the wrong one.

Track A — The User. You're a marketer, lawyer, teacher, doctor, founder, or a student in a non-CS field. Your goal is to use AI brilliantly inside the expertise you already have. 4–8 weeks. You need Part III and nothing else — no Python, no data structures, no backpropagation. Your edge is AI + your domain.

Track B — The Builder. You want to build AI systems or get hired as an AI engineer. Your goal is to understand what's happening under the API you're calling. 9–15 months, part-time. You need Stages 1 through 7, in order. Your edge is AI + systems thinking.

Read this twice: Track A is not the lesser track. A lawyer who uses AI exceptionally well inside law is worth more than a mediocre engineer. The failure isn't picking Track A — it's picking Track A and calling yourself an AI engineer. Or picking Track B and quitting in month two because nobody told you it takes a year.

And a third option nobody mentions: Track A now, Track B later. Plenty of the best AI engineers I've worked with came in sideways from another field. Domain knowledge isn't a handicap. It's a moat.

2. The honest timeline

At 8–10 hours a week. Roughly double the speed full-time; halve it if life is loud.

• Stage 1 — Python → 6–8 weeks
• Stage 2 — Object-oriented programming → 2 weeks
• Stage 3 — Data structures & algorithms → 4–6 weeks
• Stage 4 — Machine learning → 8–10 weeks
• Stage 5 — Deep learning → 6–8 weeks
• Stage 6 — LLMs → 4–6 weeks
• Stage 7 — Generative AI → ongoing, forever

To "I can build real things": ~9–12 months. To "I'm employable," add a portfolio and applications: ~12–15 months.

Anyone selling you "AI engineer in 30 days" is selling you Track A with a Track B label on it.

The encouraging half: you build useful things long before month 12. By the end of Stage 1 you can automate real work. By Stage 4 you can solve real prediction problems. This pays out continuously — it isn't a year of nothing followed by a payday.

3. The five rules

1. Every stage ends with something you built. Not something you watched. Tutorials feel like progress because they're comfortable. Building feels like failure because it's hard. That feeling is backwards.

2. Order matters. Each stage exists because the next one needs it. Jumping to agents without ML is how people end up with an "AI expert" bio and no idea what a loss function is.

3. Learn the minimum, then build, then come back. Learn ~70% and go build. The last 30% only makes sense once a real problem demands it.

4. Confusion is the job. You'll feel stupid regularly. Everyone in this field does, including the ones who look like they don't. The discomfort of not-understanding-yet is the learning.

5. Ship in public. Explaining something is how you find out whether you understood it. And opportunity finds visible people.

4. Day one: your setup

An afternoon's work that removes a hundred future headaches: Python 3.12+ · VS Code · Git and a GitHub account (your portfolio starts on day one, not month twelve) · a terminal you're not scared of · virtual environments — python -m venv .venv, learned on day one, not month six · Google Colab for free GPU · and an AI coding assistant, used as a tutor.

How to use AI while learning to code

Everyone asks this and almost nobody answers it honestly.

Do: ask it to explain code line by line · ask "why is this wrong?" after you've tried · ask for practice problems · ask it to critique code you wrote.

Don't: paste an assignment and copy the answer — you'll finish the course knowing nothing. Don't let it write code you can't read; if you can't explain every line, delete it and write it yourself.

The rule: write it yourself first, badly, then ask AI to critique it. You'll learn five times faster than the person who prompts first. The irony of this roadmap is that the fastest way to get good at AI involves deliberately not letting AI do your reps for you.

5. The maths question, answered honestly

To use AI well (Track A): none. Genuinely none.

To build with LLM APIs, RAG and agents: almost none. Basic arithmetic, a feel for probability, an intuition for "distance between two vectors." A huge amount of well-paid AI engineering sits right here.

To build and train models (Stages 4–5): intuition, not proofs. What a vector and a matrix are and what multiplying them does. What a derivative means, and therefore what a gradient does — you'll never compute one by hand. Mean, variance, distributions, correlation ≠ causation. Basic probability. About one semester of first-year maths, picked up alongside Stage 4, not before it.

To do research: yes, heavy maths. Different career, maybe 2% of jobs.

If you want it: 3Blue1Brown — Essence of Linear Algebra and Essence of Calculus. Free, visual, the best maths teaching on the internet.

Don't let maths become your excuse. I've watched more people fail from "I'm waiting until I'm better at maths" than from actually lacking maths.

PART II — THE BUILDER TRACK

---

STAGE 1 — Python

6–8 weeks. Everything in AI is Python — not because it's the best language, but because the entire ecosystem lives there.

Learn

Weeks 1–2: variables and data types · lists, dictionaries, sets, tuples, and when each is right · if/for/while · comprehensions · functions, arguments, scope.

Weeks 3–4: reading and writing files (text, CSV, JSON) · modules and imports · pip, virtual environments, requirements.txt · errors and try/except — you'll live here · calling an API with requests · argparse so your scripts take input.

Weeks 5–6: pandas (DataFrames, filtering, grouping, merging, missing data) · numpy (arrays, vectorised ops, shapes) · matplotlib (a chart that communicates something).

Weeks 7–8: no new material. Just projects.

Skip for now

Decorators, metaclasses, async/await, threading, advanced typing. You'll absorb them when a real problem demands it. Chasing them now is procrastination that feels like studying.

Free resources

• CS50P — Harvard's Intro to Python — the best free option that exists. Real graded problem sets, not passive video.
• Automate the Boring Stuff — free online, project-driven
• Real Python — best reference when you're stuck on one concept

▶ Videos: Stage 1 watch list in Part VI.

Build before moving on

1. API → CSV script. Pull from a public API (weather, currency, cricket scores), clean it, save to CSV, print a summary. Run it from your terminal.
2. A file organiser that sorts your Downloads folder by type and date.
3. A small data analysis — any Kaggle CSV, three questions answered, one chart.

All three on GitHub. This is your portfolio starting, and yes it counts.

The trap

Six months of Python tutorials. Learn the basics in three weeks, then spend four weeks building ugly, broken things and fixing them. Write ugly code. Break it. Fix it. That's the actual curriculum. Programming is not something you learn by watching someone else code.

You're done when

You can open a blank file and write a working script with no tutorial open. Googling syntax constantly is fine and never stops, for anyone.

---

STAGE 2 — Object-Oriented Programming

2 weeks. Every AI library you'll touch — PyTorch, scikit-learn, transformers, LangChain — is built from classes. If OOP is fog, those libraries stay magic. And magic can't be debugged.

Learn

Classes and objects, __init__ and self · attributes vs methods · inheritance, and when it's the wrong tool · composition, and why it usually beats deep inheritance · encapsulation · __str__, __repr__ and basic dunders · why torch.nn.Module subclassing looks the way it does — peek ahead, that's the payoff.

Skip

Design-pattern textbooks. Abstract factories. UML. You're not becoming a professor of OOP — you need to read library source code without flinching.

Free resources

• Real Python — OOP
• The real exercise: open the source of a small library you already use and follow it. Worth more than any tutorial.

▶ Videos: Stage 2 watch list in Part VI.

Build

Refactor your Stage 1 script into classes — DataFetcher, DataCleaner, ReportWriter. Same output, better structure. Feel how much easier it becomes to change.

Two weeks. Don't linger. Move.

---

STAGE 3 — Data Structures & Algorithms

4–6 weeks. This is where half of people close the tab. Stay. Not for interviews — because this is where you stop copying code and start thinking like an engineer.

Learn

Structures: arrays and lists, and what makes them fast or slow · hash maps / dictionaries — the most important item on this page · sets, and why membership testing is instant · stacks and queues · linked lists (understand, rarely write) · trees and traversal · graphs, plus BFS and DFS.

Thinking: linear vs binary search · how sorting works · Big-O — enough to explain why your loop is slow · recursion · space vs time tradeoffs.

Skip

You do not need 500 LeetCode problems. No dynamic programming. No competitive programming. That's an interview sport, not an AI prerequisite. 30–50 easy/medium problems is plenty.

Free resources

• NeetCode — free roadmap, best explanations available
• VisuAlgo — watch the structures actually move. This is what makes it click.

▶ Videos: Stage 3 watch list in Part VI.

Build

Make your Stage 2 script faster. Find the slow part, explain out loud why it's slow in Big-O terms, fix it. If you can explain why a dictionary lookup beats scanning a list, you have what this stage is for.

---

STAGE 4 — Machine Learning

8–10 weeks. Before you ever ask "how do I build an AI agent?", you need to know what a model actually is.

Learn — the foundations

What a model is: a function fitted to data. That's genuinely it. Training vs inference. Features (inputs) and labels (answers). Parameters vs hyperparameters.

The learning types: supervised (you have labelled answers) · unsupervised (you don't — find structure) · reinforcement (learn by reward; conceptually only, for now).

The tasks: classification (which category?) · regression (how much?) · clustering (what groups exist?).

Learn — the discipline

This is the part that separates people.

• Train / validation / test split — and why you never evaluate on training data
• Overfitting and underfitting — the central tension of the entire field
• Cross-validation
• Data leakage — the mistake that makes your model look brilliant and be useless
• Regularisation — the standard defence against overfitting

Learn — the maths of being wrong

Loss functions — "the model is wrong by this much", numerically. Gradient descent — conceptually, walking downhill on the loss. Learning rate — how big each step is.

Learn — evaluation

Accuracy, precision, recall, F1 · the confusion matrix · why accuracy lies on imbalanced data — a model that says "not fraud" every time is 99.9% accurate and completely worthless · choosing the metric that matches the real-world cost of being wrong.

Learn — the classic algorithms

Linear and logistic regression · decision trees → random forests → gradient boosting (XGBoost, LightGBM — still what wins on tabular data) · k-nearest neighbours · k-means · PCA.

Learn — the unglamorous 80%

Data cleaning, missing values, outliers. Feature engineering. Encoding categoricals, scaling numerics. In actual jobs, this is most of the work.

Tools: pandas · numpy · scikit-learn · matplotlib · Jupyter or Colab.

Skip

Deriving the maths by hand. Implementing algorithms from scratch — do one, linear regression, then stop. Original papers. SVM kernel theory.

Free resources

• Andrew Ng — ML Specialization — audit free. Still the best starting point in existence.
• Google ML Crash Course — fast, practical
• Kaggle Learn — short hands-on micro-courses
• StatQuest — every confusing ML concept, made clear
• scikit-learn user guide — genuinely excellent docs

▶ Videos: Stage 4 watch list in Part VI.

Build

1. A full end-to-end project. Real dataset → clean → split → train two models → compare → write a paragraph on why the better one won. That last part is the actual exercise.
2. A deliberate overfit. Build a model that scores brilliantly on training data and badly on test. Then fix it. You'll never forget overfitting again.
3. Enter one Kaggle competition. Don't try to win. Read the top public notebooks afterwards — that's where the learning is.

The trap

This is where it turns hard and unglamorous. No shiny demos, a lot of data cleaning. It's also the stage that separates people who understand AI from people who repeat AI. Push through.

You're done when

You can explain overfitting to a non-technical friend, and pick the right evaluation metric for a problem and defend the choice.

---

STAGE 5 — Deep Learning

6–8 weeks. LLMs are neural networks. You can't understand the thing you're building on if this is a black box.

Learn — the neuron and the network

What a single neuron computes: weighted sum + bias → activation. Layers, weights, biases. Activation functions (ReLU, sigmoid, softmax) — and why non-linearity is the entire point.

Learn — the training loop

The heart of all of it: forward pass → prediction. Loss → how wrong. Backpropagation → which weights caused the wrongness. Optimiser step (SGD, Adam) → adjust. Repeat.

That's the whole loop. That's all any of it is.

Learn — the practical dials

Epochs, batch size, learning rate · vanishing and exploding gradients · dropout, batch normalisation · early stopping · why GPUs matter (parallel matrix multiplication).

Learn — the architectures

• CNNs — images. Convolution, pooling, feature maps.
• RNNs / LSTMs — sequences. Understand these mainly to understand why transformers replaced them.
• Transformers — flagged here, unpacked in Stage 6.
• Transfer learning and fine-tuning — standing on a pretrained model's shoulders. This is what you'll actually do 95% of the time.

Tools: PyTorch (pick this one — it's what the field uses) · Hugging Face transformers · Colab for free GPU.

Skip

Deriving backprop on a whiteboard. Training a large model from scratch — you don't have the compute, and it teaches you less than fine-tuning does. GANs, unless you specifically want them.

Free resources

• 3Blue1Brown — Neural Networks — watch first. Unmatched visual intuition.
• Karpathy — Zero to Hero — you build a neural net, then a GPT, from scratch. Free. Extraordinary.
• fast.ai — top-down; you build working things in lesson one
• PyTorch tutorials

▶ Videos: Stage 5 watch list in Part VI.

Build

1. An image classifier on your own photos, using transfer learning. Get it wrong. Look at what it got wrong. That's the lesson.
2. A neural net from scratch in numpy — one hidden layer, toy data. Painful, ~100 lines, and it makes backprop permanently real.
3. Fine-tune a small pretrained model on a task you care about.

You're done when

You can explain what training actually changes inside a model, and read an nn.Module class and know what it does.

---

STAGE 6 — LLMs

4–6 weeks. So that when someone says "ChatGPT is an LLM," you know what that sentence means.

Learn — how the model sees text

• Tokens. Models don't see words. This single fact explains an enormous amount of weird behaviour — why models miscount letters, why some languages cost more, why "strawberry" is hard.
• Tokenisation (BPE) — and why Urdu, Arabic or Hindi text often costs far more tokens than English
• Embeddings — meaning as coordinates, similarity as distance

Learn — the architecture

Transformers — the architecture behind all of it. Attention — the idea that made this era possible: every token can look at every other token and decide what matters. Self-attention vs cross-attention, multi-head attention. Why transformers beat RNNs: parallelism and long-range context. Decoder-only (GPT-style) vs encoder-decoder.

Learn — how a model is made

Pretraining (next-token prediction at enormous scale) · fine-tuning · instruction tuning — why a raw model completes text but a chat model answers you · RLHF · LoRA / PEFT — fine-tuning cheaply, without touching all the weights.

Learn — how it behaves at inference

• Context window — what it holds at once, and what breaks at the edge
• Temperature, top-p, sampling — why output varies
• The system prompt, and why it works
• Hallucination — mechanically why: the model predicts a plausible next token, it doesn't retrieve a fact. It has no internal "I don't know" signal unless trained to produce one.
• Knowledge cutoffs
• Why the same prompt behaves differently across models — different training data, tuning, tokenisers

Practical: cost per token, and why prompt length is money · latency and streaming · open weights (Llama, Mistral, Qwen) vs closed APIs.

Free resources

• The Illustrated Transformer — still the clearest explanation on the internet
• Hugging Face LLM Course — free, hands-on, excellent
• Your model's actual API docs — Anthropic · OpenAI. Read them. Almost nobody does, and it shows.

▶ Videos: Stage 6 watch list in Part VI.

Build

1. Call an LLM API directly — no framework, no wrapper.
2. Break it on purpose. Change temperature and watch the output change. Count tokens. Overflow the context window. Get it to hallucinate, then work out why.
3. Build a tokeniser visualiser — paste text, see the tokens. Try Urdu or Hindi and watch the count explode. That's a lesson you feel.

This is where the payoff lands

Once you understand what's inside the model, prompting stops being magic.

You stop collecting "prompt hacks" and start knowing why certain instructions work. Why context matters. Why examples help. Why the model sometimes hands you confident nonsense with total conviction.

Understanding the science makes you better at using the tool. That's exactly why this roadmap puts LLMs after machine learning instead of first.

You're done when

You can explain why the same prompt behaves differently on two models — and be right.

---

STAGE 7 — Generative AI

Ongoing, forever. Now go crazy — building on understanding instead of hype.

1. Prompt engineering, properly. System prompts · few-shot · chain-of-thought · structured output · evals — how do you know prompt B beat prompt A? Measure it, don't vibe it.

2. RAG. Chunk → embed → store → retrieve → re-rank → generate. Chunk size ruins more RAG systems than model choice does. Vector databases (pgvector, Chroma, Qdrant). Hybrid search — semantic + keyword beats either alone. Then learn why naive RAG usually disappoints: bad retrieval, not a bad model, is almost always the real problem. Evaluate retrieval separately from generation.

3. Function calling and tool use. Letting a model actually do things — the bridge from chatbot to product.

4. Agents. Planning, memory, tool loops, MCP, guardrails, human-in-the-loop. And the honest question you must keep asking: does this genuinely need an agent, or is one well-written prompt better? Usually the second. Agents are the most over-applied idea in the field right now.

5. Multi-modal. Vision, image generation, speech-to-text, video. Know what each costs and where it's still unreliable.

6. Automation. n8n, Zapier, cron jobs, webhooks, queues. Where a lot of the actual money is.

7. Evaluation — the skill that gets people hired. Golden datasets · LLM-as-judge and its biases · regression tests for prompts · tracking quality over time. Almost everyone skips this. Being the person who doesn't is a career.

8. Production reality. Cost per request · latency · caching · rate limits and retries · prompt injection · PII · monitoring · what happens when the API is down at 2am.

Free resources

• DeepLearning.AI short courses — free, 1–2 hours each, genuinely good
• Hugging Face
• LangChain / LlamaIndex docs — reference only. Build once without a framework first, so you know what they're hiding.

▶ Videos: Stage 7 watch list in Part VI.

Build

One real product that someone other than you uses. One.

That single thing will teach you more than Stages 1–6 combined, and it's the only thing anyone will ask to see.

Free resources

• DeepLearning.AI short courses — free, 1–2 hours each, genuinely good
• Hugging Face
• LangChain / LlamaIndex docs — reference only. Build once without a framework first, so you know what they're hiding.

▶ Videos: Stage 7 watch list in Part VI.

Build

One real product that someone other than you uses. One.

That single thing will teach you more than Stages 1–6 combined, and it's the only thing anyone will ask to see.

---

PART III — THE USER TRACK

You're a marketer, lawyer, teacher, doctor, founder, or a student in another field. You do not need Stages 1–7. Roughly 4–8 weeks to real competence.

1. Learn one tool deeply, not ten shallowly. Pick ChatGPT or Claude or Gemini and use it daily for a month. People who "know" fifteen tools usually can't do anything remarkable with any of them.

2. Learn prompting properly — principles, not hacks:

• Context before task. The situation before the job.
• Give it a role and an audience. "You're a tax advisor writing for a first-time filer."
• Show what good looks like. One example beats three paragraphs of description.
• Ask for a specific format. Table, bullets, 200 words, JSON.
• Constrain it. "Don't invent statistics. If you're unsure, say so."
• Iterate. The first output is a draft, never the answer.
• Fresh chat when you change topic. Old context poisons new answers.

3. Learn to evaluate the output — this is the actual skill. AI is confidently wrong, constantly. Your professional expertise is what catches it. Never ship what you can't verify. The value you add isn't the prompting — it's the judgement about which output is right, and that judgement is what your years in your field bought you.

4. Learn workflows, not tricks. Map one repeating weekly task. Automate the boring 60%. Then the next one. A saved prompt you use every Monday beats fifty clever prompts you use once.

5. Know the limits. Hallucination — it invents citations, cases, statistics with total confidence. Stale knowledge. Confidentiality, the big one — never paste client, patient, student or company-confidential data into a consumer AI tool. If your organisation has no policy, that's not permission. Bias. And fluent ≠ correct — the most dangerous property of these models is that wrong answers sound exactly like right ones.

6. Optional but powerful: no-code automation — Zapier, Make, n8n, custom GPTs. Genuinely useful automations with zero programming. Many "AI consultants" do exactly this and nothing more. 7. Use AI inside YOUR expertise. This is the whole game. AI + your domain knowledge is rare and valuable. AI + no domain knowledge is a commodity.

Just don't confuse "I'm good at using AI" with "I understand AI engineering." Both are valuable. They're different skills. The internet keeps pretending they're the same one.

---

PART IV — MAKING IT COUNT

The six portfolio projects

Build them as you go, not at the end.

1. Data pipeline (after Stage 1) — API → clean → store → chart, on a schedule. Proves you can write real Python.
2. Prediction model (after Stage 4) — full ML project, honest evaluation, written analysis of why your best model won. Proves ML discipline, not just .fit().
3. Fine-tuned model (after Stage 5) — pretrained model, niche dataset, measured improvement.
4. RAG system (after Stage 7) — over documents you actually care about, with retrieval evaluation. The most in-demand skill right now.
5. An agent that does one job well — drafts email replies, monitors a site, processes invoices. With guardrails.
6. A shipped product with real users — even five. Deployed, monitored, with a cost-per-request number you can quote. This is the one that gets you hired.

For each, write a README answering: what problem, what you built, what you tried that failed, what you'd do differently. That last question is what separates a portfolio from a folder. Anyone can paste a tutorial repo. Almost nobody writes honestly about what didn't work — and hiring managers read that section first.

The roles, decoded

• AI Engineer — build products on existing models: RAG, agents, integrations, evals. Fastest-growing role, most accessible entry point. Stages 1–3, 6–7.
• ML Engineer — train, deploy and maintain models in production. Stages 1–5 + MLOps.
• Data Scientist — analysis, experimentation, statistics. Stages 1, 3–4 + heavy stats.
• Data Engineer — pipelines and warehouses; the unglamorous backbone everything depends on. Stages 1–3 + SQL/cloud.
• Research Scientist — novel architectures and papers. All stages + heavy maths, usually a PhD.
• AI Product Manager — decide what to build and whether it's working. Track A + Stage 6 concepts.

The shortest honest path to employment: AI Engineer. Stages 1–3, then 6–7. The market wants people who can ship reliable LLM products right now, and that's a shorter road than "train models from scratch."

But — and this is the whole point of this guide — an AI engineer who understands Stages 4 and 5 debugs what the others can't. When retrieval is bad, when the fine-tune won't converge, when the evals disagree with your gut, the fundamentals tell you where to look. Skip them if you must. Come back for them.

Getting hired

The portfolio beats the certificate. Nobody has ever hired from my team because of a Coursera certificate. Several because of a repo that solved a real problem, with a README that explained the thinking honestly. Certificates prove attendance. Repos prove capability.

Write about what you build. It forces you to understand it, builds a public record, and makes you findable. Most people in this field are invisible — being visible is a shortcut almost nobody takes because it feels uncomfortable.

Interviews: expect some Python, some system design ("how would you build a RAG system for X"), practical LLM questions, and questions about your own projects. Explaining your own choices deeply matters more than solving a puzzle fast.

Freelance is a legitimate route. Two real client projects teach you more than a year of tutorials — and pay you while they do it.

The uncomfortable truth about entry-level: it's harder than it was, and not because AI took the jobs. It's that everyone applies with the same three tutorial projects. One hard project explained honestly beats six shallow ones. That's a lever you control entirely.

Notes for Pakistan and the region

You don't need to leave. I went to Germany. That was my path, not the path. The work is remote-friendly and the tooling is free.

Compute is solvable. Colab gives you a free GPU; Kaggle gives free GPU hours. You need a laptop and electricity, not an expensive machine.

Free beats paid at this stage — don't pay for a bootcamp until you've finished Stage 4 for free and know you want this. Remote and freelance work is genuinely accessible, and the global rate gap is in your favour. Local demand is growing too: businesses in Lahore, Karachi and Islamabad want AI automation and can't find people who can actually build.

The mindset: "AI bohat mushkil hai, ye hum nahi kar sakte" — no. You can. But shortcuts only take you so far.

Staying current without drowning

The 90/10 rule: 90% of your time on fundamentals and building, 10% on news. One newsletter, not seven. When a new model launches, don't rebuild anything — wait two weeks and test it on your task with your evals. Benchmarks are marketing; your evals are truth.

Fundamentals don't churn. Attention, embeddings, overfitting, evaluation, retrieval — stable. The API surface changes; the ideas underneath barely move. That's why this roadmap front-loads them.

PART V — REFERENCE

The 12-month calendar

8–10 hours a week. Each month ends with proof, not a feeling.

1. Python core — your first script runs from the terminal 2. pandas, numpy, matplotlib + Project 1 — the pipeline is on GitHub 3. OOP, then DSA begins — Stage 1 refactored into classes 4. DSA, ~40 problems — you can explain why your code is slow 5. ML foundations — you can explain overfitting to a friend 6. ML practice + Project 2 — a full ML project with written analysis 7. Deep learning — a neural net built from scratch in numpy 8. Transfer learning + Project 3 — a fine-tuned model, measurably better 9. LLMs — you can explain why two models behave differently 10. Raw API calls, prompting, evals — you've broken a model on purpose 11. RAG and tools + Project 4 — a RAG system over docs you care about 12. Agents and deployment + Projects 5–6 — something you built has a real user

Fall behind? Don't restart. Just continue. The only version of this that fails is the one you abandon in month three because you missed two weeks.

PART VI — THE WATCH LIST

Free, verified live, with real view counts. ⭐ = start here. Watch that one, not all of them. This list exists so you stop searching.

Never watch passively. Code along, pause constantly, and stop every 20 minutes to build something small with the video closed. A 6-hour course watched passively teaches less than 90 minutes watched actively.

Stage 1 — Python

⭐ Learn Python — Full Course for Beginners — freeCodeCamp · 4h27m · 49.1M views

Python Full Course for Beginners — Programming with Mosh · 6h14m · 48.6M views

🇵🇰🇮🇳 Python Tutorial in Hindi — CodeWithHarry · 10h54m · 23.2M views

If you can only do one thing in Stage 1, do CS50P instead of any video — the graded problem sets are why it works. Use these to fill the gaps.

Pandas: ⭐ Complete Pandas Data Science Tutorial — Keith Galli · 1h34m · 761K views

SQL — not optional, every data and AI job assumes it: ⭐ SQL Tutorial — Full Database Course — freeCodeCamp · 4h21m · 20.9M views 🇵🇰🇮🇳 SQL Complete Course in 3 Hours — Apna College · 3h16m · 20.5M views

Stage 2 — OOP

⭐ Python OOP — For Beginners — Tech With Tim · 53m · 4.0M views

Learn Python OOP in Under 20 Minutes — Indently · 18m · 629K views

Watch the 53-minute one, then spend the fortnight refactoring your own code. Don't watch a two-hour course here.

Stage 3 — Data Structures & Algorithms

⭐ Algorithms and Data Structures — Full Course — freeCodeCamp · 5h22m · 5.9M views

Data Structures Explained — How I Wish I Was Taught — Sajjaad Khader · 16m · 1.1M views

Watch the 16-minute one first for the mental model, then the full course. Then go to NeetCode and do problems — videos alone won't build this skill.

Stage 4 — Machine Learning

⭐ Machine Learning for Everybody — Full Course — freeCodeCamp / Kylie Ying · 3h54m · 10.3M views

StatQuest — not one video, a lifeline. Every time an ML concept confuses you — bias-variance, ROC curves, gradient boosting, p-values — search "StatQuest [concept]". This channel will do more for Stage 4 than any full course.

The anchor for this stage is still Andrew Ng's ML Specialization. The videos are support, not replacement.

Stage 5 — Deep Learning

3Blue1Brown, in order. Non-negotiable.

⭐ But what is a neural network? (Ch. 1) — 19m · 23.9M views ⭐ Gradient descent — how neural networks learn (Ch. 2) — 21m · 9.4M views

Then Karpathy — the best free AI teaching that exists, by anyone, anywhere.

⭐ Neural networks and backprop: building micrograd — 2h25m · 3.9M views

It's 2h25m and will take you 8–10 hours to actually get through, because you must code along and pause. Do it anyway. When you finish, backpropagation stops being a word and becomes a thing you built.

PyTorch: ⭐ Learn PyTorch in a Day. Literally. — Daniel Bourke · 25h37m (a reference to work through over weeks) · faster: Deep Learning With PyTorch — Patrick Loeber · 4h35m

Stage 6 — LLMs

⭐ Large Language Models explained briefly — 3Blue1Brown · 8m · 7.1M views ⭐ Attention in transformers, step-by-step (Ch. 6) — 3Blue1Brown · 26m · 4.4M views How Large Language Models Work — IBM Technology · 6m · 1.6M views Transformer Neural Networks — EXPLAINED! — CodeEmporium · 13m · 885K views

Then the one that actually matters:

⭐⭐ Let's build GPT: from scratch, in code, spelled out — Andrej Karpathy · 1h56m · 7.7M views

If you watch exactly one video in this entire guide, make it that one. You build a working GPT. After it, "transformer" is no longer a word you nod at.

Stage 7 — RAG & Agents

⭐ Learn RAG From Scratch — by a LangChain engineer — freeCodeCamp · 2h33m · 1.5M views 🇵🇰🇮🇳 LLMs — How ChatGPT works & What is RAG? — CodeWithHarry · 15m · 390K views

⭐ Build a Local AI Agent with Python (Ollama, LangChain, RAG) — Tech With Tim · 28m · 514K views 🇵🇰 Build Your First AI Agent in 59 Minutes using n8n — Kashif Majeed · 59m · 159K views

A caution on the agent lane. It's the most hype-saturated corner of AI YouTube, and a lot of "build & sell AI agents" content is business-course marketing with a thin technical layer. The tutorials above are the useful kind — but keep asking the Stage 7 question: does this genuinely need an agent, or would one good prompt do it?

If you're on Track A

⭐ Large Language Models explained briefly — 3Blue1Brown · 8m — understand what you're actually using From Zero to Your First AI Agent in 25 Minutes (No Code) — Futurepedia · 26m · 4.0M views

Plus the DeepLearning.AI short courses — free, 1–2 hours each, several aimed squarely at non-engineers.

Channels worth subscribing to

Andrej Karpathy — the deepest free AI teaching on the internet · 3Blue1Brown — maths and neural network intuition · StatQuest — every confusing ML concept, clearly · freeCodeCamp — long free complete courses · Tech With Tim — practical Python and AI builds · IBM Technology — five-minute explainers of any AI term.

Who to skip: anyone whose thumbnails are shocked faces and red arrows about how AI "changed everything AGAIN." That's engagement farming — it costs you focus and teaches nothing you'll still need in six months.

The one rule for all of it

Watching this entire list would take ~100 hours and would not make you an AI engineer. Watching one video per stage and building that stage's project would.

The list is a map, not a syllabus. Use it to stop searching — then close YouTube and open your editor.

Where to start today

Open CS50P. Do the first problem set.

That's it. Not a plan, not a course selection, not more research. One problem set, today.

Then come tell me you started.

---

@techwithgul — Instagram · YouTube

This guide is free. Share it with someone stuck at "should I learn AI?"

Tools change. Fundamentals don't.