Intermediate · About 92 hours · 4 projects · Free

AI Roadmap for Developers

In about 92 hours you ship four things you can show: a classic ML model with a demo, a deep learning model on a public URL, a RAG system over your own documents, and an agent running in production with evals and monitoring.

0of 92 hours · 0%

Saved in this browser. No account, no email.

What you'll build

Go at your own pace. Stop at any milestone: each one leaves you with something to show.

  1. 1
    A classic ML model, shipped

    Take one tabular dataset from raw file to a tuned model with honest metrics, behind a demo anyone can run.

    hour 28
  2. 2
    A deep learning model you trained, tracked and deployed

    Fine-tune a pretrained model, track your runs, and deploy it on a public URL.

    hour 58
  3. 3
    A RAG system over your own documents

    Build a retrieval app over your own documents that answers with citations, score it, and put it on a public URL.

    hour 75
  4. 4
    An agent in production

    Turn your app into a monitored agent: tools, human approval, an injection guard, a container and CI.

    hour 92

Skills you'll learn

  • Python
  • pandas
  • scikit-learn
  • Cross-validation
  • Streamlit
  • MLflow
  • PyTorch
  • Backpropagation
  • Transfer learning
  • Experiment tracking
  • Gradio
  • Hugging Face Spaces
  • LLM APIs
  • Embeddings
  • Vector search
  • Chunking
  • Citations
  • Evals
  • Agents
  • Tool calling
  • Human approval
  • Prompt injection
  • Docker
  • CI
  • Observability

Prerequisites

  • You write code for a living, in any language.
  • You are comfortable with git and the command line.
  • You have a laptop that runs Python 3.11 or later. A free Colab account covers the GPU steps.

Program outline

4 milestones · 16 sections · 80 lessons · 4 projects · Every course and source is free

Learn as a feed

Milestone 1 · Hours 1 to 28 · 5 sections · 25 lessons

Python, data and your first model

Learn Python, the math you need and data work, then train and ship your first model.

Hours 1 to 50/14

By the end you have a working Python setup, a map of the field, and a script that loads, transforms and saves real data.

In the Encyclopedia: What is AI?, Python Programming for AI

  1. The map of the field in one hour55 min

  2. Python for AI: setup and the parts you actually use65 min

    • Read
      Python.org Official Tutorial · docs.python.org
    • Code
      30-Days-Of-Python · Asabeneh/30-Days-Of-Python
    • Do
      Install Python 3.12 with uv or venv, create a project repo, and write a script that uses list comprehensions, dicts and a dataclass. Run it and commit.

  3. Functions, classes, files and errors65 min

    • Read
      Automate the Boring Stuff · Free Book · automatetheboringstuff.com
    • Do
      Write a script that reads a CSV you have at work (or any public one), counts one column by category, and writes a JSON summary with error handling.

  4. CS50P as a drill set70 min

  5. The Python idioms ML code is written in65 min

Hours 6 to 110/14

By the end you can read a matrix multiplication, a gradient and a probability distribution in code, and you have written each one in plain Python.

In the Encyclopedia: Math for AI, Statistics & Probability for ML

  1. Vectors and matrices, seen65 min

  2. Matrix shapes, transformations, and why ML cares65 min

  3. Derivatives and gradients: the one calculus idea you need70 min

  4. Distributions, mean, variance and p-values65 min

  5. Bayes, conditional probability and the stats behind ML70 min

Hours 12 to 170/15

By the end you can load, clean, reshape and chart a real dataset with NumPy and pandas, and you have one SQL query and one cleaning script you will reuse.

In the Encyclopedia: NumPy, Pandas & Data Visualization, Data Engineering & Data Pipelines for AI

  1. NumPy: arrays, broadcasting, vectorized code70 min

  2. pandas: load, filter, group, join65 min

  3. Charts that tell you something70 min

  4. Cleaning real data: missing values, scaling, encoding70 min

  5. SQL and a pipeline you can rerun75 min

Hours 18 to 230/14

By the end you have trained a regression and a classification model with scikit-learn, and you can say with numbers whether either one is any good.

In the Encyclopedia: Intro to Machine Learning, Model Evaluation & Experiment Tracking

  1. Machine learning in code before theory65 min

    • Course
      Kaggle Learn · Intro to ML (Free) · Kaggle
    • Do
      Do lessons 1 to 4 of Kaggle Intro to ML. Train a DecisionTreeRegressor on the housing data and print MAE on a held-out split.

  2. Supervised learning: regression, classification, overfitting70 min

    • Course
      Google ML Crash Course (Free) · Google
    • Do
      Do the Linear Regression and Logistic Regression modules. Fit both on your cleaned dataset and plot a learning curve: training against validation error as training size grows.

  3. The whole workflow, Geron's way70 min

  4. Metrics: confusion matrix, precision, recall, ROC70 min

  5. Cross-validation and experiment tracking70 min

Hours 24 to 280/15

By the end you have shipped a complete ML project: data, features, a tuned model, honest metrics and a demo someone else can click.

In the Encyclopedia: Scikit-Learn & Hands-On ML Projects, 🧪 PRACTICE MILESTONE: Build Your First ML Project

  1. Feature engineering and pipelines70 min

  2. Gradient boosting and tuning75 min

  3. Project part 1: pick the problem, frame it, baseline it70 min

  4. Project part 2: train, evaluate, iterate65 min

  5. Project part 3: a demo someone can click65 min

Milestone 1 project · about 8 hours

A classic ML model, shipped

Take one tabular dataset from raw file to a tuned model with honest metrics, behind a demo anyone can run.

  • Python
  • pandas
  • scikit-learn
  • Cross-validation
  • Streamlit
  • MLflow

Courses that teach this

Build it

  1. Pick one tabular dataset: Titanic, House Prices, or one from your work.

  2. Clean it in a script and split it, keeping a test set you never train on.

  3. Build a scikit-learn Pipeline with preprocessing and a baseline model, then beat the baseline.

  4. Tune it and report cross-validated metrics, including where it fails.

  5. Save the model and put it behind a Streamlit form someone else can run with one command.

You finish with

A GitHub repo with clean.py, a Pipeline, a metrics table from cross-validation, a saved model, an MLflow run log, and a demo someone else can run with one command.

Check your work

  • The metrics come from cross-validation, and the test set was never used to tune.

  • The model beats a simple baseline, and the README shows by how much.

  • Someone else can run the demo with one command.

  • The README says where the model fails.

See how others did it

Milestone 2 · Hours 29 to 58 · 5 sections · 25 lessons

Deep learning with PyTorch

Write a neural network from scratch, learn PyTorch, build a small GPT and deploy a model.

Hours 29 to 340/12

By the end you have written a neural network from scratch in NumPy that learns handwritten digits, and you can explain backpropagation line by line.

In the Encyclopedia: Neural Networks & Deep Learning Fundamentals

  1. What a neural network is60 min

  2. Backpropagation65 min

  3. From scratch, with code75 min

  4. Training on MNIST in NumPy75 min

  5. Loss, activations, optimizers: the vocabulary75 min

    • Watch
      MIT 6.S191 · Intro to Deep Learning (2026) · Alexander Amini
    • Do
      Watch MIT 6.S191 lecture 1. Swap sigmoid for ReLU and plain SGD for momentum in your network, rerun, and write a 10-line note on what changed and why.

Hours 35 to 400/12

By the end you can build, train, evaluate and save a PyTorch model with a proper training loop, data loaders and GPU support, and your NumPy network is retired.

In the Encyclopedia: PyTorch

  1. Tensors and autograd70 min

    • Course
      Learn PyTorch · learnpytorch.io (Free) · learnpytorch.io
    • Do
      Do chapter 00 of Learn PyTorch. Re-implement your plain Python gradient descent with torch tensors and autograd and compare the gradients with your numerical ones.

  2. The training loop70 min

    • Read
      PyTorch Official Tutorials · PyTorch
    • Do
      Do Learn the Basics from the official tutorials. Write train.py with a model, loss, optimizer, train and eval loops, and a saved checkpoint.

  3. nn.Module, datasets and data loaders70 min

  4. micrograd: the engine under autograd75 min

  5. GPU, checkpoints, reproducibility70 min

Hours 41 to 460/16

By the end you have fine-tuned a pretrained CNN on your own images and trained a character-level RNN, and you know where each one lost to transformers.

In the Encyclopedia: CNNs & Computer Vision, RNNs, LSTMs & Sequence Models

  1. Convolutions and pooling, and why they work60 min

  2. Train a CNN on images in PyTorch75 min

  3. Transfer learning: fine-tune a pretrained ResNet75 min

  4. Sequences: RNNs, LSTMs and the vanishing gradient65 min

  5. char-RNN: generate text70 min

Hours 47 to 520/13

By the end you have built a small GPT from scratch in PyTorch, trained it on text, and you can draw attention from memory.

In the Encyclopedia: Transformers & Attention Mechanism

  1. Attention, illustrated70 min

  2. The Illustrated Transformer and the paper75 min

  3. Build GPT from scratch, part 175 min

  4. Build GPT from scratch, part 275 min

  5. Encoder, decoder, BERT, GPT and the Hugging Face library75 min

Hours 53 to 580/17

By the end your deep learning project is deployed on a public URL with a demo, and you have fine-tuned a text classifier with Hugging Face.

In the Encyclopedia: 🏗️ PRACTICE MILESTONE: Deep Learning Projects, NLP & Text Processing Fundamentals

  1. Project part 1: pick, scope, baseline60 min

  2. Project part 2: train, track, improve70 min

  3. Project part 3: deploy on Hugging Face Spaces75 min

  4. Tokens, embeddings, word2vec60 min

  5. Text classification with Hugging Face75 min

Milestone 2 project · about 10 hours

A deep learning model you trained, tracked and deployed

Fine-tune a pretrained model, track your runs, and deploy it on a public URL.

  • PyTorch
  • Backpropagation
  • Transfer learning
  • Experiment tracking
  • Gradio
  • Hugging Face Spaces

Courses that teach this

  • Practical Deep Learning for Coders

    fast.ai, Jeremy Howard · 9 lessons of about 90 min

    Build and deploy your own deep learning model on data you collect.

  • Neural Networks: Zero to Hero

    Andrej Karpathy · 8 lectures, up to 2h25m each

    Code neural networks from scratch, from backpropagation up to a GPT and tokenizer.

  • Learn PyTorch for Deep Learning

    Daniel Bourke · about 40 hours

    Write PyTorch from tensors to transfer learning, paper replication and deployment.

  • LLM Course

    Hugging Face · 6 to 8 hours per chapter

    Use, fine-tune and share language models with the Transformers library.

Build it

  1. Fine-tune a pretrained CNN on your own images, or a text classifier with Hugging Face.

  2. Measure a simple baseline first, so the model has something to beat.

  3. Run at least three tracked experiments and record what each one changed.

  4. Pick a checkpoint and say why, using the metric on held-out data.

  5. Deploy a Gradio demo on a Hugging Face Space and ask a colleague to break it.

You finish with

A public Gradio demo on a Space, the training script with seed and checkpoint control, the run log, and a README with the metric, the baseline, and what a colleague broke when they tried it.

Check your work

  • The model beats the baseline on held-out data.

  • Three runs are logged, and you can say why you chose the checkpoint.

  • The training script reproduces the result from a fixed seed.

  • A stranger can use the public demo.

See how others did it

Milestone 3 · Hours 59 to 75 · 3 sections · 15 lessons

LLMs and RAG

Call models from code, learn prompting and structured output, then build retrieval over your own documents.

Hours 59 to 640/16

By the end you call a model from code with a system prompt, structured JSON output and a tool call, and you can explain how it was trained.

In the Encyclopedia: Prompt Engineering & Using LLMs Effectively, Tool Use & Function Calling, Large Language Models (LLMs)

  1. Prompting as an engineering discipline65 min

  2. The interactive tutorial, few-shot and chain of thought75 min

  3. Tool calling and structured outputs75 min

    • Read
      Tool use with Claude · Anthropic
    • Read
      Function calling · OpenAI
    • Code
      Claude Cookbooks · Anthropic
    • Do
      Write a 60-line script in which the model must return JSON that matches a schema and call one function you define (look up a record). Validate with pydantic and reject bad output.

  4. How LLMs work, from Karpathy75 min

  5. Run one locally, read the scaling law75 min

Hours 65 to 690/15

By the end you have a working RAG pipeline over your own documents with a 20-question eval set and a score, and you know when to fine-tune instead.

In the Encyclopedia: Fine-Tuning & RAG, LLM Evaluation & Benchmarks

  1. RAG, embeddings and vector search65 min

  2. Build the RAG pipeline75 min

  3. Fine-tuning: LoRA and PEFT65 min

  4. Fine-tune a small model yourself70 min

  5. Evals: your RAG needs a score65 min

Hours 70 to 750/15

By the end your LLM app is live on a public URL with its eval score in the README, and you have generated an image from code.

In the Encyclopedia: 🚀 PRACTICE MILESTONE: Build & Deploy an LLM App, Generative AI

  1. Project part 1: the app skeleton70 min

  2. Project part 2: chat UI with streaming65 min

  3. Project part 3: deploy75 min

  4. Project part 4: workflows before agents60 min

  5. Generative media from code70 min

Milestone 3 project · about 8 hours

A RAG system over your own documents

Build a retrieval app over your own documents that answers with citations, score it, and put it on a public URL.

  • LLM APIs
  • Embeddings
  • Vector search
  • Chunking
  • Citations
  • Evals

Courses that teach this

Build it

  1. Collect the documents you want to ask questions about, your own or a public set.

  2. Split them into chunks, create embeddings, and store them in a vector index.

  3. Retrieve the top passages for a question and answer from them, with citations.

  4. Write 20 golden questions with expected answers and score retrieval and answers.

  5. Change one thing, such as chunk size or reranking, and show the score move.

  6. Put it on a public URL with the eval score in the README.

You finish with

A live URL, the repo, the golden set, and the eval score in the README.

Check your work

  • Every answer cites the passage it came from.

  • The 20-question golden set has a score for retrieval and for answers.

  • One change moved the score, and the README shows before and after.

  • It says it does not know when the documents do not answer.

See how others did it

  • RAG Evaluation

    huggingface.co

    Build a filtered synthetic question set, then score RAG answers with a judge.

  • Retrieval Augmented Generation

    anthropics/claude-cookbooks

    Compare retrieval levels on a labeled eval set using precision, recall, MRR, accuracy.

  • Citations

    anthropics/claude-cookbooks

    Return answers that cite exact passages from plain text and PDF documents.

  • Cinnamon/kotaemon

    Cinnamon/kotaemon

    Working document chat app with PDF citation highlights, Docker images, hosted live demos.

Milestone 4 · Hours 76 to 92 · 3 sections · 15 lessons

Agents and shipping

Add agents, security, containers, logging and monitoring, then write it all up.

Hours 76 to 810/14

By the end your app has an agent loop that plans, calls two tools and stops, plus a written prompt-injection threat model and one test that proves a guard.

In the Encyclopedia: AI Agents & Agentic AI, Prompt Injection & Jailbreaking

  1. What an agent is, from first principles75 min

  2. Hugging Face Agents Course, unit 170 min

  3. LangGraph: state, nodes, edges70 min

  4. MCP: tools as a protocol65 min

  5. Prompt injection: the threat model70 min

Hours 82 to 870/14

By the end the app runs in a container with a CI test, request logs and a cost counter, and you have trained an RL agent on a toy environment to understand RLHF.

In the Encyclopedia: MLOps & Deploying AI Models, Reinforcement Learning Deep Dive

  1. Serving: containers and an API70 min

  2. Testing and CI for ML code70 min

    • Course
      Made With ML · End-to-end ML projects · madewithml.com
    • Do
      Do the testing and CI/CD lessons of Made With ML. Add pytest tests for the retriever and for the eval score threshold, and a GitHub Actions workflow that runs them.

  3. Logging, tracing and cost65 min

  4. Versioning data and models, and the runbook65 min

  5. RL in one hour, and what RLHF is75 min

Hours 88 to 920/18

By the end your project has a responsible-use note and a public write-up, you have a weekly habit for staying current, and you have reproduced one number from a paper.

In the Encyclopedia: AI Safety, Ethics & Responsible AI, Build Your AI Portfolio & Get Hired, Reading Research Papers & Staying Current

  1. Safety and fairness for your app70 min

  2. Make it a portfolio75 min

  3. How to read a paper65 min

  4. A system for staying current70 min

  5. Reproduce one number70 min

Milestone 4 project · about 10 hours

An agent in production

Turn your app into a monitored agent: tools, human approval, an injection guard, a container and CI.

  • Agents
  • Tool calling
  • Human approval
  • Prompt injection
  • Docker
  • CI
  • Observability

Courses that teach this

Build it

  1. Add an agent loop to your app that plans, calls two tools and stops by itself.

  2. Put a human approval step in front of any action that changes something.

  3. Write a prompt-injection threat model and one test that proves your guard works.

  4. Run the app in a container, with a CI test on every commit.

  5. Log each request with its tokens and cost, and write a runbook for when it breaks.

  6. Publish a responsible-use note and a 600-word write-up of your projects.

You finish with

The repo with tests passing in CI, the threat note, the responsible-use note, and a 600-word public write-up of your projects.

Check your work

  • The agent stops by itself and cannot loop forever.

  • Any action that changes something waits for approval.

  • A test proves the injection guard works, and CI runs it.

  • Every request logs its tokens and cost.

See how others did it

Check yourself at the end

  • Train, evaluate and ship a classic ML model with scikit-learn, with cross-validated metrics you can defend in a code review.

  • Write and debug PyTorch training code: data loaders, training loops, checkpoints, transfer learning, and a small GPT you built from scratch.

  • Call hosted and local LLMs from your own code with system prompts, structured JSON output and tool calls, with a golden-set eval that gates every prompt change.

  • Build and deploy a RAG application over your own documents, then turn it into an agent with tools, a human-approval step and a prompt-injection threat model.

  • Run an LLM app in production: containerized, tested in CI, logged with tokens and cost per request, with a runbook to rebuild the index and roll back.

  • Read a research paper in three passes, reproduce one of its numbers, and keep a weekly habit that keeps your stack current.