Level 1 / entry / open to anyone

Twenty minutes from now, you're driving a car you programmed.

Nothing to install — it runs in your browser. Twelve weeks later that same instinct has turned into an autonomous robot in ROS 2 that maps a world it's never seen, finds itself in it, and navigates it. Twenty-five minutes a day is all it asks of you, and at the end you own something you can show people.

Enroll — $990 What you'll be able to do

Specification

Lessons84

Per lesson~25 min

Default pace12 weeks

FastestUp to you

PrereqCan write code

HardwareNone

StartAny Monday

RefundThrough wk 2

Where you end up

Six things you'll be able to do in week twelve that you can't do today.

Put a robot in a room it has never seen, and have it build a map of that room, work out where it is inside the map, and drive itself to a place you name.
Look at a robot that just drove into a wall, read the frames and the covariance on screen, and say which of six things caused it — instead of restarting and hoping.
Write a PID controller from the equation up, and tune it by reasoning about the response rather than turning knobs until it stops wobbling.
Open an unfamiliar ROS 2 codebase — the kind you'd meet on your first day — and find your way around it without a tutorial.
Explain to another engineer why coordinate frames are the hard part of robotics, and draw the transform tree for your own machine on a whiteboard.
Point at a public repository with your name on it, containing a working autonomous system, a write-up of how it works, and a video of it running.

That last one is the one that changes what happens to your job applications. Everything above it is what makes you able to defend it when someone asks.

Why you'll actually finish this one

Build it naive. Feel it break. Then learn why the tools exist.

Almost every robotics course starts with the framework and hopes you'll infer the problem it solves. That's backwards, and it's why people bounce off ROS.

Here you spend four weeks writing an autonomous vehicle from nothing — your own sensor filter, your own PID, your own state machine — in a browser simulator with zero setup. You find out firsthand what's hard. Then you meet ROS 2, and in week ten you port your own code into it. The framework stops being arbitrary the moment it's solving a problem you personally hit.

Curriculum

Eighty-four days, and what you can do at the end of each one.

Read this as a list of capabilities you pick up in order, not as a syllabus. Every week ends with something running that didn't run the week before.

Part 1

Write an autonomous vehicle from scratch

Browser-based. Nothing to install.

Wk 01

Drive it yourself

The bicycle model, coordinate frames, manual control. You're driving within twenty minutes of enrolling.

Wk 02

Make it sense

Simulated LiDAR, ray casting, sensor noise, and your first hand-written filter. Find the centerline.

Wk 03

Make it think

P, then PD, then PID — derived, implemented term by term, and tuned systematically rather than by guessing.

Wk 04

Make it robust

State machines, obstacle avoidance, waypoints, pure pursuit. Ends with a timed autonomous lap.

Part 2

Learn the professional stack

Now the tools make sense, because you've hit the problems they solve.

Wk 05

The environment every robotics job assumes

Ubuntu, the shell as roboticists actually use it, git, build tooling, and the C++ you'll meet in real codebases. Compressed — you already program.

Wk 06–07

ROS 2 for people who've built distributed systems

Nodes, topics, services, actions, parameters, launch files, colcon, rviz, rosbag — taught as what they are: a message bus with strong opinions.

Wk 08

Your robot, in a world

URDF and Gazebo. Build a robot body, give it sensors, put it somewhere with things to run into.

Part 3

Make it autonomous

Your code, professional tools, one working robot.

Wk 09

Transforms and odometry

TF2, frame trees, wheel odometry and why it drifts. The moment coordinate frames click is the moment you become a roboticist.

Wk 10

Port your own stack

Your week-three PID and week-four pure pursuit, rewritten as ROS 2 nodes driving the simulated robot. Same algorithms, professional plumbing.

Wk 11

Mapping and navigation

SLAM and Nav2. Build a map, localize in it, navigate it — and learn to read the failure modes on screen when it goes wrong.

Wk 12

Capstone

A full autonomous run, written up, recorded, and pushed to your GitHub.

On localization, honestly. You will configure, run and debug professional localization — slam_toolbox and AMCL — not write one from scratch. That's the right depth for this level, and it isn't a consolation prize: most robotics jobs involve tuning AMCL, not implementing it. Being the person who can look at a screen and say "your covariance is diverging because your wheel radius is wrong" gets you hired. Writing the estimator yourself is Level 2.

How it reaches you

One lesson a day, in your inbox. Faster if you want it faster.

Each morning you get the day's lesson. You work through it, you write code, and you reply with a difficulty rating so I know whether it's landing.

Twelve weeks is the default, not a rule

If you've got the time and it's clicking, ask for more and I'll send more. Some people run two or three lessons a day and finish in half the time. Nothing gets watered down — you just get through it sooner.

Coming soon

An AI tutor in Slack

A private channel with a tutor that knows your entire lesson plan — it nudges you when you drift and answers questions about the material at eleven at night. Not live yet. Everyone who enrolls now gets it when it ships, at no extra cost.

Weekly office hours, and how to get the most out of them. One group call a week, open to everyone. Submit your question at least 24 hours beforehand — that way I can dig into it properly and come back with a real answer instead of an off-the-cuff one, and everybody else gets the benefit of the question too.

To be straight with you about what this doesn't include: private time with me, or individual review of your code. That's what The Forge is for, and I'd rather tell you now than have you find out in week three.

Honest constraints

What this costs you that isn't money.

Per lesson~25 min

Per week5–7 hrs

Lessons84

Default pace12 weeks

This is built to fit around a full-time job, and it is still eighty-four days of showing up. Nobody has ever absorbed this material by reading it — you write code every single day, and the days you skip are the days it stops compounding. If you can't find twenty-five minutes daily, wait until you can. I'd rather you enroll in March and finish than enroll today and stall in week five.

What it's worth to you

Where people take this next.

Foundations is a laptop-only program, so be clear-eyed about what it is: it makes you someone who can build robot software and prove it. Three honest destinations from there.

Into a robotics team at work

The most common route, and the least discussed. Plenty of people don't change employer — they become the one at their current company who can talk to the robotics or automation group, and get moved onto it.

Into applications that get answered

Robotics teams screen for evidence you've made a machine work. A public repo with a working autonomous stack and a video is that evidence. It gets you the first call; the rest is on you.

Into hardware, properly

Some people finish and want to feel a real motor stall. That's The Forge — and you'll get four times as much out of it having done this first.

What I'm not telling you. That this gets you a job. It doesn't, on its own — nothing you can buy does. Robotics hiring also looks at years of experience, at where you are, and at whether a team has a seat open. What this removes is the specific reason you're being passed over right now, which is that there's nothing in your history showing you can make a robot work.

Investment