Several CIT courses work directly from projects published by labs and open-source teams, including Built on a Princeton IROM Lab, Built on a Caltech AMBER Lab, Built on a University of Colorado Boulder, Built on a Stanford Vision and Learning Lab, Built on a Stanford ILIAD Lab. Students read the project as five boxes, open exactly one of them, change one value, and compare what moved.
Published 17 August 2026 · Updated 17 August 2026
In front of an unfamiliar program, the place students get stuck is not knowing where to look first. So every course asks the same five questions, whatever the subject.
Input
What comes in?
Memory
What persists?
Process
What transforms?
Output
What leaves, and who uses it?
Control
What decides when anything runs?
Control is the fifth box on purpose. It is the hardest element to find in real code and it otherwise hides inside process; finding what decides when things run usually reveals the architecture.
RocketPy-Team/RocketPy at pinned commit 9bd6ad3af8f9, read as five boxes. The gold box is the one the lesson opens.
Each box carries the file paths it rests on. Students open those files, check whether their reading was right, and correct it. A path that does not exist at the pinned commit fails the build.
1. Write the prediction first
Before opening the repository the student writes down all five boxes. Being wrong is fine; being blank is not, because the gap is the lesson.
2. Open exactly one box
Each course designates one box: usually where the naive guess is wrong, or where the field's real difficulty lives.
3. Change one value
Opening a box means perturbing it, not reading it. Change one constant, swap one function for a dumber one, and watch which way the output moves.
4. Close it again in one sentence
The student compresses the box into one line naming an assumption and a failure mode. Borrowing the source's own vocabulary does not pass.
A beautiful diagram never completes the item, because a beautiful diagram can be drawn without understanding anything.
Each entry carries the chain that project runs, from what comes in to what leaves, in its own words. The course guide names the files that course opens.
irom-princeton/AdaptSim · 9cf80fb42687 · opens 12 of 178 text files
The student runs experiments that close the gap between a simulated robot and a real result, one value at a time.
The real result → Candidate ranges → Pick next values → Tuned values
peterdsharpe/AeroSandbox · 60998b5c3935 · opens 7 of 2,908 text files
The student changes one allowed range in a wing design program and watches how far drag and wing length move.
Ranges, conditions → Variables, limits → Aero and iteration → Chosen wing, limits
Caltech-AMBER/ambersim · 47a9c1848154 · opens 12 of 40 text files
The student lowers the force a simulated robot is allowed and watches how its way of balancing changes.
Model, start pose → Angles and weights → One step, one score → Score curve, policy
AVSLab/basilisk · 441418f2f4e1 · opens 9 of 2,964 text files
The student changes one timing value in a satellite control program and sees how long it then takes to point.
Target and sensors → The messages → The control law → Commands and error
StanfordVL/BEHAVIOR-1K · 78980ee463b9 · opens 8 of 3,548 text files
The student opens the household-task definitions from a Stanford lab and explains why deciding what counts as success is the hard part.
Task and scene → Objects and states → Physics and check → Observation, done
Stanford-ILIAD/CARLO · 1dc7ebe4ca1f · opens 5 of 12 text files
The student changes only the pedestrian's speed in a junction scene and finds where the risk suddenly jumps.
Roads and placing → Positions, shapes → Move, then overlap → Picture, collision
RobotLocomotion/drake · b07bab525ccb · opens 10 of 5,297 text files
The student finds where state is gathered in robotics software used by university labs, and explains it in their own words.
Models and ports → One shared context → Physics and wiring → Values at the ports
metrica-sports/sample-data · e706dd506b36 · opens 4 of 10 text files
The student changes one assumption over a match's coordinate data and sees how far the reading of space moves.
Position, events → Coordinate table → The student's rule → The student's chart
roboflow/sports · 42c80c06b6b6 · opens 6 of 20 text files
The student separates the pipeline that turns football video into a top-down view, then changes one value to see what breaks.
One video frame → Pitch dimensions → Detect and map → Minimap and video
SkillCorner/opendata · c1e17a0cc3e0 · opens 10 of 88 text files
The student folds match tracking data on their own terms and sees how the choice of what to count changes the answer.
Coordinates, info → Frames and phases → Folding to metrics → Tables and charts
SoccerNet/sn-gamestate · 1c9583450672 · opens 11 of 113 text files
The student removes one module from a public match-video pipeline and finds which stage was holding the result up.
Frames and config → The joined tracks → Find, read, map → Pitch view, score
AtomScott/SportsLabKit · 9591d6db9e8d · opens 11 of 167 text files
The student runs two or three trackers over the same video on the same terms and finds where each one breaks.
Frames and boxes → The track list → Matching boxes → Paths and errors
hudl/open-data · b0bc9f22dd77 · opens 5 of 8,979 text files
The student decides what to count in public football records and sees that changing the definition changes the conclusion.
The match file → The event list → The counting rule → Tables and charts
WangYixuan12/interactive_world_sim · 3ba69b41d070 · opens 10 of 144 text files
The student compares an AI's predicted scene with the real motion and finds where the prediction starts to slip.
Video and actions → Latent and weights → Making the next → Prediction, score
SIGRobotics-UIUC/LeKiwi-sim · c3e38133450b · opens 2 of 5 text files
The student changes one value in a robot model file and sees how the motion changes.
The model files → Only while running → The physics engine → Made when it runs
mani-skill/ManiSkill · 62ff3a5896b4 · opens 8 of 822 text files
The student changes only the number of practice scenes and checks whether faster also means better.
Task and cameras → One packed array → Move, then score → Observation, score
NanoComp/meep · 3e7b7fee0da4 · opens 10 of 482 text files
The student changes only the cell size in a wave computation and finds when the answer starts to be trustworthy.
Space and cell size → Field per cell → From neighbours → Flux and pictures
GaTech-RL2/mimiclabs · 0b81d7e8cc07 · opens 10 of 3,986 text files
The student grows a few demonstrations into many layouts and checks whether the extra examples actually help.
Demos and task file → Demos and ranges → Transplanting → Examples and check
RussTedrake/manipulation · cdb8c90f402c · opens 8 of 338 text files
The student works through a pick example from MIT open course material and explains which computation decides the outcome.
Station, point data → Pose and waypoints → Pose, then path → Target poses
reilleya/openMotor · 0dfb3f1dd4f8 · opens 9 of 168 text files
The student changes one value in a saved motor example and sees how pressure and thrust move.
Shape, properties → Depth and surface → Area into thrust → Curves and impulse
openrocket/openrocket · 133b558de556 · opens 8 of 1,738 text files
The student follows the compute order of a widely used rocket design program and checks what one delayed event does to the result.
Design and motor → The status object → Aero, one step → The flight data
Jianghanxiao/PhysTwin · 54106c6357e3 · opens 11 of 147 text files
The student changes the material values of an object rebuilt from video and sees how its bending changes.
Video and masks → Points and springs → Fitting the values → The replayed motion
projectchrono/chrono · 9faf13dd8f11 · opens 7 of 6,321 text files
The student changes only the ground model in a rover simulation and weighs the change in driving against the change in cost.
Rover and ground → Poses and contacts → Solving contacts → Distance and slip
empriselab/RCareWorld · ae0900be3e45 · opens 10 of 438 text files
The student widens one safety distance in a care-robot simulation and sees how the way it works changes.
Layout and sensors → Per-object values → Solving the joints → Picture, readings
ARISE-Initiative/robomimic · d309eaecc18a · opens 7 of 163 text files
The student compares directly how the amount and quality of demonstration data change what a robot learns.
Demos and config → Dataset and weights → One training step → The saved policy
ARISE-Initiative/robosuite · 5ce6643f3092 · opens 13 of 422 text files
The student changes the control rate in a robot-arm simulator and explains why the same commands give a different result.
The action in → Scene and state → Torques and physics → Observation, reward
gtbook/robotics · 49315552e7f6 · opens 10 of 94 text files
The student raises the sensor error and watches how far the robot loses track of itself.
Reading and action → Probability spread → Redistributing → Belief and choice
sonofeft/RocketCEA · 5bde04e274d5 · opens 8 of 665 text files
The student changes one ratio in a propellant pair and finds that the hottest case is not the best case.
Pair and pressure → The rewritten card → Solving the gases → Values with units
RocketPy-Team/RocketPy · 9bd6ad3af8f9 · opens 11 of 707 text files
The student changes one value in a rocket simulator and sees how apogee and landing point move.
Rocket and weather → The state vector → Equations of motion → Altitude, landing
rail-berkeley/serl · 1fa2af7496be · opens 14 of 153 text files
The student separates the parts of a robot that learns by trying, and compares runs with and without the demonstration data.
Camera and demos → The replay buffer → Judge, then update → The next command
intelligent-control-lab/spark · 2823c9ef3a35 · opens 10 of 215 text files
The student tests a safety layer for robots working near people, in simulation only, and explains the trade-off between speed and clearance with numbers.
Joints and people → The safety index → The safe command → The final command
tudat-team/tudatpy · 2300d7fe3d7d · opens 11 of 2,238 text files
The student adds and removes one force in an orbit computation and sees how far apart the satellite ends up a day later.
Start and forces → The state vector → Adding the forces → State over time
RussTedrake/underactuated · 26e9a5bbb5b9 · opens 11 of 331 text files
The student lowers the motor force on a swinging robot and sees how its way of balancing changes.
Model, start pose → Angle and rate → The control law → Trace and outcome
A shop, a study, a notebook: what the student handles directly is read through the same boxes. Elementary courses stop at four; the control box arrives in middle school.
the multi-agent experiment that tests one research question a student set · 5 boxes · no repository
The student separates the experiment into five boxes, changes the agent count, and compares against the baseline on the same tasks.
Question, tasks → Shared state → Agents at work → Against baseline
the data-driven helper a student builds · 4 boxes · no repository
The child separates their helper into four boxes, changes one label, and checks how the verdict moves.
Examples, ask → Examples, labels → Rule, classifier → Answer, check
the small business a student runs, and its forecast · 5 boxes · no repository
The student separates their own business into five boxes and compares results while keeping the rule of changing one value at a time.
Past sales, price → The profit table → Next week forecast → This week's call
the agentic software product a student builds · 5 boxes · no repository
The student separates their product into five boxes, changes one call ceiling, and compares results on the same evaluation set.
Request, eval set → Loop state → Modules, tools → Verified result
the analysis notebook the student writes · 5 boxes · no repository
The student separates their own analysis notebook into five boxes and reruns it from the top to check the result holds.
Table and columns → The table in memory → Aggregate and fit → Chart and reading
the Python app a student wrote, with one AI feature attached · 5 boxes · no repository
The student separates their app into five boxes, changes one retry ceiling, and checks where failed requests end up.
Request, files → Store, session → Code, model call → Checked result
the small shop a student runs in class · 4 boxes · no repository
The student separates their own shop into four boxes, changes one price, and checks how the sales record moves.
What customers need → Today's record → Price, make, sell → The money left
the smart helper a class runs on rules · 4 boxes · no repository
The child separates the helper into four boxes, changes one value, and checks how the action moves.
What it noticed → The state now → If, then → What it did
These courses pin a version the same way; their five-box reading is still being written.
harvard-edge/AirLearning · 9ec5bab2bbec · structure only
This course works from a pinned version of this repository; the five-box reading is still being written.
The five-box map
The student's map with the file paths behind it, and which box was opened.
Before and after
The result before the change, the result after it, and the prediction written first.
One sentence
The student's own summary, plus the condition under which it stops holding.
A university name or a project source is not admissions evidence by itself. The student has to explain what they understood and did, and no course guarantees an admission or an award.
No. Naming a lab says who published the open project. CIT designed the course independently; it is not an affiliation or an endorsement, and it is unrelated to admission or award outcomes.
No, the opposite. The lesson is practice in leaving most of a project closed. In the RocketPy course, for example, about ten of some seven hundred text files are opened. Deciding where to stop is the skill.
Drawing the map never completes the item. The student has to close the opened box again in one sentence that names one assumption and one way it fails.
It depends on the course. Some stop at reading a pinned repository; others run it and change a value. A consultation checks the student's experience and available computer before choosing a starting point.
Each project's licence is recorded with the course, and no upstream source is copied into CIT materials. The lessons link to the pinned version instead.
Open projects keep changing. If the example moves during a course, a student cannot tell what caused a result to change, so CIT records the reviewed commit and uses only that version.
We check the student's grade, coding so far, interests, and available computer, then suggest a starting point.