RobotnixAcademy
← Courses

Computing

Python Development: From Code to AI

A self-paced Python development course that starts with source code, execution, variables, decisions, loops, and functions, then grows into debugging, data structures, files, Git, modules, packages, program architecture, APIs, automated testing, AI-assisted development, coding-agent control, and a final code defense. Small examples can run inside the Robotnix reader; multi-file projects, Git, virtual environments, packages, network work, pytest, and the capstone use a real Python workspace. Learners progress by evidence, not by a calendar, and no AI tool is required to complete the course.

Structure
18 units
Audience
Grades 9-12
Entries
126
Pacing
Self-paced

Unit 01

  1. overviewUnit 1: Welcome to ProgrammingA program is not the text you type into an editor. It is a set of instructions that must survive a chain:
  2. Lesson 1What Is Programming?Core path: 30 minutes
  3. Lesson 2Meet the Python InterpreterCore path: 30 minutes
  4. Lesson 3The Developer WorkflowCore path: 30 minutes
  5. Lesson 4Make the Computer ObeyCore path: 35 minutes
  6. Lesson 5Your First Code DefenseCore path: 30 minutes
  7. reflectionUnit 1 Evidence Check: Source to OutputOpen the small program you used for your first Code Defense.

Unit 02

  1. overviewUnit 2: Your Development EnvironmentThe editor is not Python. The terminal is not Python. The file explorer is not the filesystem. A Run button is not magic.
  2. Lesson 1Meet Your Development EnvironmentCore path: 30 minutes
  3. Lesson 2Files, Folders & ProjectsCore path: 30 minutes
  4. Lesson 3The Terminal Is Not ScaryCore path: 35 minutes
  5. Lesson 4Build Your WorkspaceCore path: 35 minutes
  6. Lesson 5Prove What Environment You Are Actually UsingCore path: 30 minutes
  7. reflectionUnit 2 Checkpoint: Prove the EnvironmentImagine somebody opens your project and says, “Python is broken.”

Unit 03

  1. overviewUnit 3: Variables, Data & InputPrograms become interesting when values can change while the program runs.
  2. Lesson 1Variables and ValuesCore path: 30 minutes
  3. Lesson 2Data Has TypesCore path: 25 minutes
  4. Lesson 3Input Makes Programs InteractiveCore path: 30 minutes
  5. Lesson 4Build a Player Profile GeneratorCore path: 35 minutes
  6. Lesson 5Follow the ValueCore path: 30 minutes
  7. reflectionUnit 3 State TraceTake one input from your Unit 3 program and trace it from the keyboard to the final output.

Unit 04

  1. overviewUnit 4: Decisions in CodeA conditional is a policy written in code.
  2. Lesson 1True, False, and ComparisonsCore path: 30 minutes
  3. Lesson 2`if`, `elif`, and `else`Core path: 30 minutes
  4. Lesson 3Combining ConditionsCore path: 30 minutes
  5. Lesson 4Build an Access Control SimulatorCore path: 35 minutes
  6. Lesson 5Hunt the BoundaryCore path: 30 minutes
  7. reflectionUnit 4 Boundary ReviewPick the most important threshold from your decision program.

Unit 05

  1. overviewUnit 5: Loops & AutomationRepetition becomes automation only when you understand what changes on each pass and why the repetition stops.
  2. Lesson 1Repeating With `for`Core path: 25 minutes
  3. Lesson 2Counters, Accumulators, and Repeated DecisionsCore path: 30 minutes
  4. Lesson 3`while` Loops and Unknown RepetitionCore path: 30 minutes
  5. Lesson 4Build an Automated System MonitorCore path: 35 minutes
  6. Lesson 5Loop ForensicsCore path: 30 minutes
  7. reflectionUnit 5 Loop ForensicsChoose one loop from your project and freeze it after three iterations.

Unit 06

  1. overviewUnit 6: Functions & DecompositionCopy and paste can make a program longer. It cannot make the responsibilities clearer.
  2. Lesson 1Building Your First FunctionsCore path: 30 minutes
  3. Lesson 2Parameters, Arguments, and Return ValuesCore path: 30 minutes
  4. Lesson 3Decomposition, Scope, and Program DesignCore path: 30 minutes
  5. Lesson 4Refactor the System MonitorCore path: 35 minutes
  6. Lesson 5Function Contracts Under PressureCore path: 30 minutes
  7. reflectionUnit 6 Function Contract CheckSelect one function you wrote and document it without showing its body first:

Unit 07

  1. overviewUnit 7: Debugging Like a DeveloperDebugging is not the part of programming where you randomly change code until the red text disappears.
  2. Lesson 1Read the EvidenceCore path: 30 minutes
  3. Lesson 2Debugging Is an InvestigationCore path: 30 minutes
  4. Lesson 3Debugging With VS CodeCore path: 30 minutes
  5. Lesson 4Investigate the Broken System ConsoleCore path: 35 minutes
  6. Lesson 5Build the Bug Case FileCore path: 30 minutes
  7. reflectionUnit 7 Case ClosureReopen one bug you solved.

Unit 08

  1. overviewUnit 8: Strings, Lists & DictionariesThe moment your program needs more than a few isolated values, data structure becomes an architecture decision.
  2. Lesson 1Strings Are Data Structures TooCore path: 30 minutes
  3. Lesson 2Lists and CollectionsCore path: 30 minutes
  4. Lesson 3Dictionaries and Structured DataCore path: 30 minutes
  5. Lesson 4Build a Player Roster ManagerCore path: 35 minutes
  6. Lesson 5Choose the Structure Before You Fight ItCore path: 30 minutes
  7. reflectionUnit 8 Data Structure DefenseChoose one real structure from your program.

Unit 09

  1. overviewUnit 9: Files & Persistent DataMemory disappears when a process ends. Files let a program leave state behind.
  2. Lesson 1Reading and Writing FilesCore path: 30 minutes
  3. Lesson 2Paths, Missing Files, and File OrganizationCore path: 30 minutes
  4. Lesson 3CSV and JSONCore path: 30 minutes
  5. Lesson 4Make the Player Roster Survive a RestartCore path: 35 minutes
  6. Lesson 5What Survives When the Program Dies?Core path: 30 minutes
  7. reflectionUnit 9 Persistence TestClose the program. Start it again. Load the data.

Unit 10

  1. overviewUnit 10: Git & GitHubGit is not a cloud backup button. It is a system for recording and comparing project states.
  2. Lesson 1Repositories, Status, and CommitsCore path: 30 minutes
  3. Lesson 2Inspect Changes Before You CommitCore path: 30 minutes
  4. Lesson 3GitHub, Push, README, and Remote HistoryCore path: 30 minutes
  5. Lesson 4Put Your Project Under Version ControlCore path: 35 minutes
  6. Lesson 5Read Git History Like EvidenceCore path: 30 minutes
  7. reflectionUnit 10 Repository ArchaeologyPick three commits from your own history.

Unit 11

  1. overviewUnit 11: Modules, Libraries & Packagesimport looks like one keyword. Behind it is an entire dependency boundary.
  2. Lesson 1Modules and the Python Standard LibraryCore path: 30 minutes
  3. Lesson 2Building Your Own ModulesCore path: 30 minutes
  4. Lesson 3Packages, `pip`, and Virtual EnvironmentsCore path: 25 minutes
  5. Lesson 4Build a Modular System ToolkitCore path: 35 minutes
  6. Lesson 5Where Did That Import Come From?Core path: 30 minutes
  7. reflectionUnit 11 Import TraceChoose one import from each category you actually used:

Unit 12

  1. overviewUnit 12: Objects & Program ArchitectureA class is not a graduation ceremony for “advanced Python.” Sometimes a dictionary and two functions are the clearer design.
  2. Lesson 1Classes, Objects & InstancesCore path: 25 minutes
  3. Lesson 2Methods Put Behavior With the DataCore path: 25 minutes
  4. Lesson 3Program ArchitectureCore path: 25 minutes
  5. Lesson 4Refactor the Player Roster Into ObjectsCore path: 35 minutes
  6. Lesson 5Follow One Object Through the SystemCore path: 30 minutes
  7. reflectionUnit 12 Architecture DecisionPick one class from your work, or one place where you deliberately chose not to use a class.

Unit 13

  1. overviewUnit 13: APIs & The InternetFor the first twelve Units, most of your program’s truth lived inside the process or on local disk. Now part of the system can live somewhere else.
  2. Lesson 1Requests, Responses & HTTPHow does a Python program ask another system for something without sharing its memory or files?
  3. Lesson 2Calling an API With PythonYou now have the protocol model. The next job is making Python perform the request without hiding the evidence you will need when it fails.
  4. Lesson 3External Data Can FailCore path: 25 minutes
  5. Lesson 4Build a Remote Task DashboardCore path: 35 minutes
  6. Lesson 5The API Is Outside Your Trust BoundaryCore path: 30 minutes
  7. reflectionUnit 13 Boundary TraceTake one dashboard run and label the evidence by layer:

Unit 14

  1. overviewUnit 14: Testing & Reliable CodeA program running once is an observation. A test is a repeatable claim about behavior.
  2. Lesson 1Test Cases, Assertions & Edge CasesHow do you prove a function still works after you change it?
  3. Lesson 2Automated Testing With `pytest`A pile of assert statements can prove ideas. A test framework turns those checks into a repeatable development tool.
  4. Lesson 3Testing Real ApplicationsSome functions are easy to test because they receive values and return values.
  5. Lesson 4Build a Verification SuiteCore path: 35 minutes
  6. Lesson 5Turn the Bug Into a TestCore path: 30 minutes
  7. reflectionUnit 14 Test Evidence ReviewPick the single test in your suite that gives you the most confidence.

Unit 15

  1. overviewUnit 15: AI-Assisted DevelopmentAn AI coding interface can produce an answer faster than you can review it. That speed is useful only if your review process is stronger than your urge to accept plausible-looking code.
  2. Lesson 1What Is an AI Coding Assistant?AI coding tools can produce code that looks finished before you have had time to understand the problem.
  3. Lesson 2Prompt, Inspect, VerifyA prompt is not a spell. It is the beginning of a change request.
  4. Lesson 3AI for Explanation, Debugging, and Test DesignGenerating new features is only one use of an AI coding tool, and often it is the use with the largest review burden.
  5. Lesson 4Build a Feature With AI AssistanceCore path: 35 minutes
  6. Lesson 5Review AI Output Like a Pull RequestCore path: 30 minutes
  7. reflectionUnit 15 Candidate ReviewChoose one AI-generated or supplied candidate change.

Unit 16

  1. overviewUnit 16: Specification-Driven AI DevelopmentFast generation changes the bottleneck.
  2. Lesson 1Specification Before GenerationCore path: 25 minutes
  3. Lesson 2Build in Verified Slices, Not ExplosionsOnce the specification exists, the next danger is scale.
  4. Lesson 3Verification After Fast GenerationFast generation creates an uncomfortable illusion: the project can look almost finished before you have established that the new code belongs there.
  5. Lesson 4Build the System Status Console in Verified SlicesCore path: multiple sessions
  6. Lesson 5Know When to Stop the GeneratorCore path: 30 minutes
  7. reflectionUnit 16 Change-Budget AuditPick one implementation slice from your project.

Unit 17

  1. overviewUnit 17: Coding Agents & Repository ControlA chat response can suggest an edit. A coding agent may be able to inspect files, search a repository, edit multiple files, run commands, and react to tool results.
  2. Lesson 1From Assistant to AgentA coding assistant can return a suggestion. A coding agent may be able to take actions in a development environment.
  3. Lesson 2Specification-Driven Agent WorkA vague coding task gives an agent room to invent architecture, scope, and even the meaning of “done.”
  4. Lesson 3Agent Execution, Review & RecoveryThe agent says:
  5. Lesson 4Run an Agent-Guided Project SprintCore path: 35 minutes
  6. Lesson 5The Agent Said It Was Done. Prove It.Core path: 30 minutes
  7. reflectionUnit 17 Agent Claim vs. Repository EvidenceWrite one claim an agent made about its work, for example:

Unit 18

  1. overviewUnit 18: Capstone & Code DefenseStop adding features.
  2. Lesson 1Finish the System, Not the FantasyThe capstone is not the moment to prove you can invent more features.
  3. Lesson 2Build the Evidence PackageYour repository contains code. The capstone needs something stronger: a trace from what you claim to why another person should believe the claim.
  4. Lesson 3Code DefenseA polished demo answers:
  5. Lesson 4Capstone Verification & Code DefenseCore path: multiple sessions
  6. Lesson 5Leave the Project So Someone Else Can Trust ItCore path: 30 minutes
  7. reflectionFinal Ownership RecordDo not write a generic course reflection. Build a handoff note for the developer who receives your project next.