Stanford's Robotics Degree, for Free: the 6-month path to Robot Learning Engineer (RESOURCES)

For the academic year 2026-27, tuition for full-time graduate engineering students at Stanford costs $23,239 per quarter.

This totals approximately $70,000 annually, excluding housing expenses in Palo Alto.

Stanford has subtly placed a substantial part of its robotics coursework on YouTube, allowing anyone to watch it at no cost.

The same instructors, slides, and lectures are provided as in the conventional classroom experience.

Among the teaching staff are the Senior Director of Autonomous Vehicle Research at NVIDIA, the creator of Physical Intelligence, and a guest lecturer who oversees AI initiatives at Tesla Optimus.

Very few individuals view these resources in the intended sequence.

Some individuals embark on the well-known Andrew Ng machine learning course, feel a sense of achievement for a fortnight, and subsequently do not interact with robotics again.

Others might begin with a lecture on deep reinforcement learning, encounter the term 'Bellman' within the first four minutes, and exit the page.

Certain viewers may attend a viral humanoid seminar and then attempt to create a robot policy without an understanding of what a Jacobian is.

The result is invariably the same: countless hours of lectures have been viewed, and yet, nothing has been created.

The challenge does not stem from the content itself; rather, it is the order of presentation that is problematic.

A student at Stanford doesn't randomly select lectures. There is an organized progression: starting with mathematics, followed by the robot's physical structure, then its perception, followed by planning, and finally learning.

This guide reformulates that order using exclusively free materials from Stanford.

• 119 lectures across 7 Stanford courses and seminar series

• about 95 hours of video in total, roughly 4 hours a week - 2 free textbooks written by Stanford faculty

• 6 practice projects that run on a normal laptop with no robot and no GPU

• 1 optional $122 robot arm for the final month

Every link below was checked in September 2026, and every lecture count and duration was pulled directly from the official Stanford Online playlists

This isn't a Stanford degree. You won't get a diploma, office hours or a grade

What you get is the knowledge, and that's the part employers test in interviews

Important!!!

I'm going to break down the best lectures from this list one by one on X, with timestamps for the exact moments worth watching, so you don't have to sit through 95 hours to find them

If you want the short version of every lecture, follow me: https://x.com/0x_meden

Now let's start ⬇

Why robot learning, and why Stanford

Every company in the humanoid race is hiring for the same thing: people who can make robots learn from data instead of being programmed line by line

Tesla Optimus, Figure, 1X, Physical Intelligence, Skild. Different robots, same job description

And the people who define this field teach at Stanford, or come to Stanford to give talks:

• Chelsea Finn teaches CS224R Deep Reinforcement Learning. She's a Stanford professor and a co-founder of Physical Intelligence, one of the best-funded robot AI companies

• Marco Pavone co-teaches AA203 Optimal and Learning-Based Control. He's a Stanford professor, a former NASA JPL roboticist, and a Senior Director of Autonomous Vehicle Research at NVIDIA

• Oussama Khatib teaches CS223A Introduction to Robotics, the course that has trained generations of robotics engineers

• Ashish Kumar, the AI lead for Tesla Optimus, gave a guest lecture in CS224R about how RL moves robot intelligence forward

That lineup is the reason to learn from Stanford. You're taking the course from the people who build the robots

What a robot learning engineer truly does

A robot learning engineer operates at the intersection of two domains

On one hand, there is classical robotics, which includes kinematics, control, and planning. This mathematical foundation has enabled robot arms to function in factories for four decades.

Conversely, on the other hand, machine learning encompasses neural networks, imitation learning, and reinforcement learning. This innovative aspect empowers robots to fold laundry and manipulate unfamiliar objects.

The majority of individuals typically grasp only one side

Professionals in machine learning may develop a policy but struggle to clarify the reasons behind the arm's shaking movement.

Engineers specializing in robotics can optimize a controller, yet they may lack the ability to utilize 10,000 demonstrations effectively.

The exceptional, well-compensated individual comprehends both areas, which is precisely what this path cultivates.

In the concluding lecture of AA203, Dr. Daniele Gammelli elaborates on the functionality of a self-driving car's decision stack and the role of learning within it:

• the first layer where learning became standard was perception

• end-to-end models are now progressing into the planning phase

• even the most optimistic end-to-end companies refrain from allowing learning to influence the lowest layer, where strict safety constraints are present

This is the reason both components are significant. Learning will be applied at the top of the stack, while control theory will be utilized at the base.

Month 1: The math that everything else stands on

Your goal this month: become comfortable with vectors, matrices and least squares, because every later course assumes it

Every robotics course eventually turns into matrices. Rotation is a matrix. A robot's position is a matrix. A camera is a matrix. A controller is a matrix

If this part is shaky, every lecture after it feels like a foreign language

The Stanford course

1. ENGR108: Introduction to Applied Linear Algebra, Stephen Boyd (free)

Link: https://www.youtube.com/playlist?list=PLoROMvodv4rMz-WbFQtNUsUElIh2cPmN9

54 short lectures, most of them 10 to 30 minutes, about 18.5 hours in total

This is the most beginner-friendly Stanford math course on YouTube. Boyd teaches linear algebra as a tool to use, not as proofs, and the course ends with control and state estimation examples, which is exactly where robotics picks it up

2. Vectors, Matrices, and Least Squares, Boyd & Vandenberghe (free book)

Link: https://web.stanford.edu/~boyd/vmls/

The companion textbook, free as a PDF, with exercises and code companions

The companion textbook, free as a PDF, with exercises and code companions

What to focus on

- Vectors, norms, distances and angles (lectures 2 to 12)
- Matrix-vector multiplication as "a function that moves things" (lectures 17 to 23)
- Least squares, the single most used idea in robotics (lectures 33 to 36)
- Linear dynamical systems, your first look at how a robot's state changes over time (lecture 26)
- Linear quadratic control and state estimation (lectures 48 and 49), a preview of Month 4

What to skip

- Lecture 47 on portfolio optimization, unless you're curious
- The k-means lectures (13 and 14) can wait

Practice task

Install Python with NumPy and Jupyter

Then do three things:

• fit a line through 50 noisy points using least squares, first by hand with the formula and then with np.linalg.lstsq, and check that you get the same answer

• write a function that rotates a 2D point by any angle using a rotation matrix, and plot a square rotating in 10-degree steps

• simulate a simple linear dynamical system x(t+1) = A x(t) and plot what happens when you change A

All three will come back later: least squares in sensor calibration, rotations in kinematics, and linear systems in control

Month 1 Milestone

By the end of this month you should be able to:

- multiply a matrix by a vector in your head for 2x2 cases and explain what it did geometrically
- solve a least squares problem and explain why it's "the best fit"
- rotate points with a rotation matrix in code
- simulate a linear system in a loop and plot it

Month 2: The robot's body, from Oussama Khatib

Your goal this month: understand how a robot arm moves, where its hand is, and how much force its motors need

This is the part robot learning people skip most often, and it's the part that breaks their policies later

When a learned policy fails, it's often not the neural network. It's a wrong coordinate frame, a joint limit, or a singularity nobody understood

The Stanford course

1. CS223A: Introduction to Robotics, Oussama Khatib (free)

Link: https://www.youtube.com/playlist?list=PL65CC0384A1798ADF

16 lectures, about 19 hours in total

These lectures were recorded years ago and the video quality shows it. The content hasn't aged, because the math of how a robot arm moves hasn't changed. Lecture 1 alone has more than 769,000 views

2. CS223A course page on Stanford Engineering Everywhere (free)

Link: https://see.stanford.edu/Course/CS223A

Handouts, problem sets and exams from the course, free to download

What to focus on:

- Spatial descriptions: how to describe where something is and how it's turned
- Forward kinematics: given the joint angles, where is the hand?
- Inverse kinematics: given where the hand should be, what are the joint angles?
- The Jacobian: how joint speeds turn into hand speeds. This one idea shows up in almost every robot controller you'll ever read
- Dynamics: why the motors need different torque depending on how the arm is posed
- Position and force control, the preview of Month 4

Practice task

Install MuJoCo, the free physics simulator from Google DeepMind

Link: https://github.com/google-deepmind/mujoco_menagerie/tree/main/trs_so_arm100

Load the model of the SO-ARM100, the same open-source robot arm you can optionally build in Month 6

Then:

- read the joint angles from the simulator and compute the gripper position yourself with forward kinematics, and check it against the simulator's answer
- write a simple inverse kinematics solver that moves the gripper to a target point
- find a pose where the arm loses a degree of freedom (a singularity) and explain what happened using the Jacobian

When your math and the simulator agree on where the gripper is, you understand the robot's body

Month 2 Milestone

By the end of this month you should be able to:

- describe the position and orientation of any object with a transform
- compute forward kinematics for a simple arm by hand and in code
- solve inverse kinematics numerically
- explain what the Jacobian is to someone who has never heard of it
- load a real robot model in MuJoCo and move it with your own code

Month 3: How a robot sees and senses

Your goal this month: understand how cameras, IMUs and lidar turn the physical world into numbers, and how neural networks read those numbers

A robot that can't see can only repeat the same motion forever. Perception is the layer where machine learning first took over robotics, and it's still where most robot learning starts

The Stanford courses

1. CS231N: Deep Learning for Computer Vision, Spring 2025 (free)

Link: https://www.youtube.com/playlist?list=PLoROMvodv4rOmsNzYBMe0gJY2XS8AQg16

18 lectures in total. You need 10 of them this month, about 11.5 hours

This is one of the most famous deep learning courses in the world, and the 2025 version is fully up to date with transformers and robot learning

Watch:

- Lectures 1 to 6: classification, neural networks, backpropagation, CNNs
- Lecture 8: attention and transformers
- Lecture 9: detection and segmentation
- Lecture 15: 3D vision
- Lecture 17: Robot Learning, by Yunzhu Li of Columbia. Save this one for the end of the month, it's the bridge to everything that follows

2. EE259: Principles of Sensing for Autonomy (free)

Link: https://www.youtube.com/playlist?list=PLoROMvodv4rOhE007XQu707Dy52qXiZGV

21 lectures on GPS, IMUs, sonar, radar, lidar and cameras.

You only need 5 of them, about 5.5 hours:

- Lectures 5 and 6: how accelerometers and gyroscopes actually work
- Lecture 7: inertial navigation and dead reckoning, and why position estimates drift
- Lecture 15: how lidar works
- Lecture 19: how a camera forms an image

This is the course most robot learning people never watch, and it's why they're surprised when a real sensor doesn't behave like the simulator

What to focus on

- How a CNN turns pixels into a prediction, and what backpropagation actually does
- Why transformers took over vision
- Detection and segmentation, because a robot needs to know where things are, not only what they are
- Sensor noise and drift, and why a robot's estimate of where it is gets worse over time
- The difference between what a camera sees and what a lidar sees

Practice task

Add a camera to your MuJoCo scene from Month 2 and place three colored objects on the table

Then:

- render images from the simulated camera and train a small CNN in PyTorch to find the position of one object in the image
- use your Month 2 inverse kinematics to move the gripper above the predicted position
- add random noise and lighting changes to the images and watch the accuracy drop

That last step is your first taste of the sim-to-real gap, the difference between clean simulated data and messy real data

Month 3 Milestone

By the end of this month you should be able to:

- train and evaluate a CNN in PyTorch
- explain attention in one paragraph without equations
- explain why an IMU drifts and why lidar and cameras fail in different ways
- connect a vision model to a robot arm in simulation, so it sees an object and moves toward it

Month 4: Planning and control, from the NVIDIA autonomy lab

Your goal this month: learn how a robot decides what to do next, mathematically, when it knows how the world works

This is the classical half of the stack, the part that still runs the lowest, safety-critical layer of real robots and cars

The Stanford course

1. AA203: Optimal and Learning-Based Control, Spring 2026, Marco Pavone and Daniele Gammelli (free)

Link: https://www.youtube.com/playlist?list=PLoROMvodv4rNsMOMF1LG3ohsTqZVJVeVp

19 lectures in total, all recorded in Spring 2026. This month you watch lectures 1 to 12, about 15.5 hours

This is the newest course on the list and the most direct line to how autonomous vehicles are built today. Pavone runs autonomous vehicle research at NVIDIA

2. Principles of Robot Autonomy, Gammelli, Lorenzetti, Luo, Zardini and Pavone (free book)

Link: https://porabook.com

The companion textbook, written by the same team that teaches AA203, free online with Python exercises in Jupyter notebooks. Cambridge University Press is publishing the print edition

3. AA203 course page (free)

Link: https://stanfordasl.github.io/aa203/sp2526/

Slides for every lecture and the full schedule

What to watch, lecture by lecture

- Lecture 1: course overview
- Lectures 2 to 6: optimization, and the two families of methods for computing the best trajectory
- Lecture 7: dynamic programming, the idea underneath all of reinforcement learning
- Lecture 8: LQR, the most famous controller in robotics. You've already seen a preview in ENGR108 lecture 48
- Lecture 9: what happens when the world is random
- Lecture 10: reachability analysis, which is how you prove a robot will never enter a dangerous state
- Lectures 11 and 12: Model Predictive Control, the method that drives most real autonomous systems today

What to focus on

- The idea of a cost function: every behavior you want becomes a number to minimize
- Dynamic programming and the Bellman equation, because Month 5 is built on it
- LQR, until you can implement it from memory
- MPC: plan ahead, take one step, re-plan. Robots and self-driving cars do this dozens of times per second

Practice task

Use the MuJoCo cart-pole model (a pole balanced on a moving cart), or write a simple cart-pole simulation in Python yourself

Link: https://gymnasium.farama.org/environments/mujoco/

Then:

- linearize the system around the upright position and balance the pole with LQR
- replace LQR with a simple MPC controller and add a limit on how hard the cart can push
- push the pole with a random force and compare how both controllers recover

If you can balance a pole with LQR and then with MPC, you understand the core of classical control better than most people who apply for robot learning jobs

Month 4 Milestone

By the end of this month you should be able to:

- write a robot's goal as a cost function
- explain dynamic programming and the Bellman equation
- implement LQR and MPC from scratch
- explain why MPC re-plans at every step
- explain what reachability analysis guarantees and why safety teams care about it

Month 5: Teaching robots instead of programming them

Your goal this month: learn imitation learning and reinforcement learning, the two ways robots learn skills from data

This is the month everything connects. You'll see that reinforcement learning is dynamic programming from Month 4, done without knowing the rules of the world in advance

The Stanford courses

1. AA203, lectures 13 to 19 (free)

Link: https://www.youtube.com/playlist?list=PLoROMvodv4rNsMOMF1LG3ohsTqZVJVeVp

About 9.5 hours. The same course as Month 4, now moving from control to learning:

- Lecture 13: intro to learning
- Lecture 14: intro to imitation learning and RL
- Lecture 15: imitation learning
- Lecture 16: fundamentals of RL
- Lecture 17: value-based methods like Q-learning
- Lecture 18: policy optimization
- Lecture 19: model-based RL, and a summary of the whole stack from perception down to the motors

2. CS224R: Deep Reinforcement Learning, Spring 2025, Chelsea Finn (free)

Link: https://www.youtube.com/playlist?list=PLoROMvodv4rPwxE0ONYRa_itZFdaKCylL

19 videos. This month you watch 7 of them, about 7.5 hours:

- Lecture 2: imitation learning
- Lecture 3: policy gradients
- Lecture 4: actor-critic methods
- Lecture 6: Q-learning
- Lecture 7: offline RL, learning from a fixed dataset without touching the robot
- Lecture 11: model-based RL
- Lecture 16: RL for Robots, where Finn explains why robots still aren't autonomous

Lecture 1 of this course has more than 164,000 views, and it's worth watching too if you want the big picture first

3. CS224R course page (free)

Link: https://cs224r.stanford.edu/

Optional deeper theory: CS234 Reinforcement Learning, Emma Brunskill (free)

Link: https://www.youtube.com/playlist?list=PLoROMvodv4rN4wG6Nk6sNpTEbuOSosZdX

Watch this if AA203 and CS224R move too fast for you. It's slower and more mathematical

What to focus on

- Behavior cloning: copying demonstrations, and why it fails when the robot drifts off the path it was shown
- Policy gradients and PPO. In AA203 lecture 19, Gammelli calls PPO probably one of the most popular RL algorithms out there, if not the most popular
- Q-learning and why it can learn from old data
- Offline RL, because real robots are expensive to run and most robot data is collected once and reused
- Model-based RL, and why an optimizer will exploit every mistake in a learned model of the world

Practice task

Install Stable-Baselines3, a free library with ready implementations of PPO and SAC

Link: https://stable-baselines3.readthedocs.io/

Then:

- train PPO on a MuJoCo environment from Gymnasium, for example the Hopper, and plot the learning curve
- train the same environment with SAC and compare how many steps each needs
- go back to your cart-pole from Month 4, record 50 episodes of your LQR controller balancing it, and train a small neural network to copy it with behavior cloning
- push the cloned policy off its usual path and watch it fail, then explain why using what you learned in AA203 lecture 15

You now have a controller you designed and a policy that learned from it. Comparing the two is a strong interview story.

Month 5 Milestone

By the end of this month you should be able to:

- explain the difference between imitation learning and reinforcement learning
- train PPO and SAC and read a learning curve
- explain why behavior cloning drifts and how methods like DAgger fix it
- explain the difference between model-free and model-based RL, and when each one wins
- connect RL back to the dynamic programming from Month 4

Month 6: The frontier, and your first real robot

Your goal this month: learn where robot learning is heading right now, and build one project on a real or simulated arm that proves everything you learned

The Stanford lectures and seminars

These are guest lectures and seminars from the people building the current generation of robot AI. About 8.5 hours in total:

1. CS231N Lecture 17: Robot Learning, Yunzhu Li (Columbia)

Link: https://www.youtube.com/watch?v=XSfmOH_xVSU

Deep RL, model learning and robotic manipulation in one lecture. If you watched it in Month 3, watch it again. It will look like a different lecture now

2. CS224R Lecture 17: Advancing Robot Intelligence, Ashish Kumar, AI Lead at Tesla Optimus

Link: https://www.youtube.com/watch?v=Hp1WBWghrak

3. CS224R Lecture 18: Frontiers, Chelsea Finn

Link: https://www.youtube.com/watch?v=FacJ_1tTSx4

4. Robotics Seminar: Gen Control, Action Chunking, Moravec's Paradox, Max Simchowitz (CMU)

Link: https://www.youtube.com/watch?v=D7e7oUbtkFM

Mathematical evidence for why the "easy" things are hard for robots, and the key ideas in modern robot learning

5. Robotics Seminar: 𝚿0, An Open Foundation Model for humanoid loco-manipulation, Yue Wang (USC)

Link: https://www.youtube.com/watch?v=popjDuA-whA

6. Robotics Seminar: Manipulation Data Pyramid, Yang Gao (Tsinghua)

Link: https://www.youtube.com/watch?v=99wIpauDEmY

How to combine internet video, human teleoperation and robot experience so that each fills the gaps of the others

7. Robotics Seminar: Embodied Foundation Models, Jonas Frey (Stanford)

Link: https://www.youtube.com/watch?v=5uWtpDON7Vs

Why sim-to-real works for walking robots, and why it's still hard for manipulation

8. Robotics Seminar: Robot Learning from Human Experience, Danfei Xu (Georgia Tech, NVIDIA)

Link: https://www.youtube.com/watch?v=NUtaN10cVDc

How robots can learn from video and data recorded by humans

9. AI and Robotics: Chelsea Finn and Andrew Ng

Link: https://www.youtube.com/watch?v=IT734HriiHQ

A 33-minute conversation that ends with a section on how to get into robotics and reinforcement learning

Full Stanford Robotics Seminar archive (free)

Link: https://stanfordasl.github.io/robotics_seminar/

New talks get added every quarter. Once you finish this path, watching one a week is how you stay current

What to focus on

- Action chunking: predicting a short sequence of actions at once instead of one at a time
- Foundation models for robots, and why they need huge and varied datasets
- The data problem: internet video, teleoperation and robot experience, and what each one is good for
- Sim-to-real: why it works well for walking and much less well for grasping

The final project, three budget tiers

$0: simulation only

Use LeRobot from Hugging Face, the open-source library for robot learning with datasets and pretrained policies

Link: https://huggingface.co/docs/lerobot/index

Train an imitation learning policy on one of its simulated tasks, evaluate it, and then change the task slightly, like moving the object or changing its color, to measure how well it generalizes

$122: one SO-101 follower arm, if you 3D-print the parts

Link: https://github.com/TheRobotStudio/SO-ARM100

That's the official US parts list for a single follower arm, excluding printing. You'll control it with the code you've written since Month 2

$230: the full leader and follower pair

The official US parts list for both arms comes to $229.88, excluding printing. You move the leader arm by hand, the follower copies it, and LeRobot records every movement as training data

Record 50 demonstrations of one simple task, like putting a block in a cup, train a policy, and let the arm do it alone

Practice task

Whatever tier you choose, the deliverable is the same: a GitHub repository with a README, a 30-second video, and one honest paragraph about what failed

Include three numbers:

- the success rate on the task you trained
- the success rate when you change one thing in the scene
- how many demonstrations or training steps it took

That second number is the one interviewers care about most. Everyone can make a demo work once. Very few people measure how it breaks

Month 6 Milestone

By the end of this month you should be able to:

- explain what a robot foundation model is and what data it needs
- explain action chunking and why it helped imitation learning
- train and evaluate an imitation learning policy with LeRobot
- present one robot project with numbers, a video, and an honest failure analysis
- follow new robot learning research on your own through the Stanford seminar series

The full curriculum on one page

Month 1  |  ENGR108 Applied Linear Algebra
         |  54 lectures, ~18.5 h, Stephen Boyd

Month 2  |  CS223A Introduction to Robotics
         |  16 lectures, ~19 h, Oussama Khatib

Month 3  |  CS231N Computer Vision + EE259 Sensing
         |  14 lectures, ~17 h

Month 4  |  AA203 Optimal Control, lectures 1-12
         |  ~15.5 h, Marco Pavone & Daniele Gammelli

Month 5  |  AA203 lectures 13-19 + CS224R Deep RL
         |  14 lectures, ~17 h, incl. Chelsea Finn

Month 6  |  Seminars: Tesla Optimus, CMU, USC,
         |  Tsinghua, Georgia Tech, Finn & Ng
         |  9 talks, ~8.5 h

Total    |  119 lectures, ~95 hours
         |  2 free textbooks
         |  6 projects
         |  $0 to $230 in hardware

How to actually finish this

• Watch at 1.25x speed. Most lectures are still easy to follow, and it saves about 19 hours over the whole path

• Never watch more than two lectures without writing code. The practice tasks are the course. The videos are just support

• Keep the free textbooks open next to the video. When a professor goes too fast, the book usually explains the same idea more slowly

• Put every project on GitHub from day one, with a README explaining what broke and how you fixed it

• Budget 2 hours a day: about 1 hour of lectures, 1 hour of code. Keep your job while you do this

How to actually finish this

• Watch at 1.25x speed. Most lectures are still easy to follow, and it saves about 19 hours over the whole path

• Never watch more than two lectures without writing code. The practice tasks are the course. The videos are just support

• Keep the free textbooks open next to the video. When a professor goes too fast, the book usually explains the same idea more slowly

• Put every project on GitHub from day one, with a README explaining what broke and how you fixed it

• Budget 2 hours a day: about 1 hour of lectures, 1 hour of code. Keep your job while you do this

What this won't give you

• A diploma. If a job requires a degree on paper, this doesn't replace it

• Feedback. Nobody will grade your code, so the numbers in your final project are your grade

• A network. Stanford students meet their future co-founders and employers in class. You'll have to build that online, by sharing what you build

That last point is also the opportunity. The people who post their progress publicly while working through material like this get noticed by the same companies that hire from Stanford

Stanford put a large part of its robotics curriculum online for free

Almost nobody watches them in order and builds something at the end, and the few who do are the ones who end up getting hired

I hope this was useful for you ❤️