To build a high-school homeschool computer science curriculum, combine structured instruction in programming, algorithms, data structures, debugging, and AI-era code verification with independent projects, professional tools, and documented assessments. Brilliant can provide the interactive instruction and practice spine; add Git and version control, three increasingly independent projects, and any AP, credit, or transcript requirements. A parent does not need to be a programmer, but should choose the destination, protect the schedule, review progress, and arrange human code review when needed.
The goal is not to finish a collection of coding tutorials. It is to make the teenager capable of planning, building, testing, explaining, and improving a program they have not seen before.
Course and practice counts audited September 2026.
Choose the learner’s destination
The right sequence depends on what the teenager wants the course to accomplish.
| Goal | Recommended emphasis | Required supplement |
|---|---|---|
| General computer science literacy | Programming foundations, Python, algorithms, debugging, and computational reasoning | One or two original projects |
| Learn Python seriously | The Python sequence from program state through functions, object-oriented programming, recursion, algorithms, and data structures | Local editor, Git, and blank-editor practice |
| Prepare for college computer science | Python fluency, code tracing, recursion, algorithms, complexity, and data structures | Larger assignments, timed assessments, and any language required by the college course |
| Prepare for AP CSP | Programming, data, algorithms, and computational reasoning | AP pseudocode, systems and networks, computing impacts, and the Create task |
| Prepare for AP CSA | Program design, objects, methods, control structures, testing, and collections | Java syntax, Java collections, and official AP questions |
| Build a portfolio | Selected Brilliant courses plus substantial independent work | Three polished projects, repositories, documentation, and presentations |
| Explore software or AI careers | Specification, decomposition, debugging, algorithms, and verification | Security, APIs, databases, web development, and AI-agent workflows |
Choose the correct starting point
| Learner’s experience | Good starting point |
|---|---|
| No prior coding | Begin with Thinking in Code or Thinking in Python. |
| Coming from Scratch or another block language | Begin with typed Python, code tracing, and debugging. See The next step after Scratch. |
| Has written basic Python | Use a challenge task to check variables, conditionals, loops, and collections, then consider Functions in Python. |
| Already builds small programs with functions | Move into object-oriented programming, recursion, algorithms, and data structures. |
| Preparing for AP CSA | Check programming concepts, then add Java from the beginning. |
| Experienced learner | Skip or sample beginner material and require harder assessments and projects. |
A well-matched starting point should require thought without repeatedly blocking the learner on prerequisites. Brilliant’s course placement and level checks can guide work inside Brilliant, but they do not determine school placement or award credit.
Use a structured instruction and practice spine
Brilliant’s current code-writing curriculum includes 10 courses, 274 lessons, 618 practice sets, and 3,282 problems across four Foundations courses and six Python courses.
Foundations courses
- Thinking in Code
- Programming with Variables
- Programming with Functions
- Algorithmic Thinking
Python courses
- Thinking in Python
- Functions in Python
- Object-Oriented Programming in Python
- Recursion in Python
- Algorithms in Python
- Data Structures in Python
The curriculum includes:
| Practice type | Current audited count |
|---|---|
| Run-and-edit code problems | 2,081 |
| Problems requiring learners to diagnose or repair code | 689 |
| Problems requiring learners to design or revise an algorithm | 561 |
| Problems involving data structures or collections | 329 |
| Explicit code-tracing and output-prediction problems | 161 |
These totals were counted directly from the interactives in the ten code-writing courses. See How Brilliant’s coding coverage was audited for the scoring method, evidence, and limitations.
Start Python by writing, running, and repairing code
Thinking in Python currently includes:
- 70 lessons and 874 exercises;
- executable Python in all 70 lessons;
- 61 lessons where learners diagnose or repair a bug;
- 301 working programs or real-world features where learners complete the core logic.
The course introduces variables, conditionals, loops, lists, dictionaries, data manipulation, and search through executable problems. It is a foundation, not the whole homeschool course: learners still need to write programs outside guided lessons.
Teach the coding skills that endure in the age of AI
AI can produce code quickly. The durable human skills are deciding what is worth building, specifying what the program must do, decomposing the work, directing AI without losing the design, verifying its output, reasoning across levels of abstraction, building incrementally, and securing the result.
The Coding with AI half of Brilliant’s Coding Skills Framework organizes those durable capabilities into seven Big Ideas, 37 learning objectives, and 106 skills:
| Big Idea | What the learner should practice |
|---|---|
| Taste | Decide what is worth building and define a successful outcome. |
| Developing Incrementally | Work in small, functioning, verifiable, and reversible steps. |
| Specification & Design | State requirements, constraints, components, interfaces, and tests before implementation. |
| Designing Workflows | Direct AI agents to implement a specification, and design the workflow that gets there. |
| Verification | Test, review, debug, observe, and evaluate the result. |
| Security | Treat inputs and AI output as untrusted, protect secrets, and test misuse cases. |
| Abstraction | Move between the user’s goal, system design, algorithm, and code. |
A September 2026 audit found that Brilliant’s strongest coverage is in verification, debugging, specification, decomposition, and abstraction. Independent projects should deliberately add the current gaps: deciding what is worth building, version-control workflows, security, end-to-end delivery, and directing or reviewing AI-generated code.
For every substantial project, require the learner to answer:
- What problem is worth solving?
- What must the result do, and what constraints apply?
- How will the problem be divided into components?
- What evidence will prove that the program works?
- Which normal, boundary, and adversarial cases should be tested?
- If AI generated code, can the learner explain, test, repair, and safely integrate it?
Follow a semester or year plan
This is an illustrative 36-week plan. Adjust the sequence after placement and according to the family’s credit requirements.
| Period | Structured study | Independent work | Evidence to preserve |
|---|---|---|---|
| Weeks 1–4 | Programming foundations and the beginning of Thinking in Python | Modify and trace short programs | Placement notes and code-tracing assessment |
| Weeks 5–10 | Variables, conditionals, loops, and collections | Constrained Python project | Specification, tests, and debugging log |
| Weeks 11–16 | Functions, decomposition, and contracts | Multi-function program | Design document and code review |
| Weeks 17–22 | Object-oriented programming and recursion | Data-model or recursive project | Explanation, test suite, and revision history |
| Weeks 23–28 | Algorithms, data structures, correctness, and complexity | Implement and compare two approaches | Correctness and efficiency analysis |
| Weeks 29–36 | Goal-specific study: capstone, AP, college preparation, or another language | Independent capstone | Repository, demonstration, rubric, and reflection |
A semester version can end after one substantial project and a cumulative assessment. A full-year version should include the capstone and the goal-specific supplement.
Build three increasingly independent projects
- Constrained project: Build from a clear specification and supplied tests.
- Open-ended project: Choose the problem, define success, and design the tests.
- Capstone: Plan, build, test, document, revise, and present a substantial program.
Possible projects include a text game, simulation, data-analysis tool, puzzle generator, study tool, small automation, or application that solves a real family or community problem.
For each project, preserve:
- the specification and intended user;
- success criteria and constraints;
- design notes and component responsibilities;
- code and revision history;
- tests for normal, boundary, and failure cases;
- debugging record;
- final demonstration;
- reflection on trade-offs, limitations, and next improvements.
Capstone rubric
| Area | Evidence of success |
|---|---|
| Problem definition | A clear user, need, inputs, outputs, constraints, and definition of done |
| Decomposition | The program is divided into coherent components with clear responsibilities |
| Correctness | Normal, boundary, and failure cases are tested |
| Debugging | The learner can reproduce failures, state hypotheses, test repairs, and verify that other behavior still works |
| Code quality | Clear names, functions, documentation, and limited duplication |
| Computer science reasoning | The learner can explain the selected data structures, algorithm, and trade-offs |
| Independence | The learner can explain and modify the code without copying a finished solution |
| AI verification | Any AI-generated code is reviewed, tested, explained, and checked for unsafe assumptions |
| Communication | A concise demonstration and reflection explain what works, what does not, and what should improve next |
Have a programmer, teacher, mentor, or technically experienced peer review at least the capstone if the parent cannot evaluate the code.
Make debugging and verification core subjects
Debugging is not a detour from programming. It is programming.
For every project, keep a short log:
| Field | Example |
|---|---|
| Failure | Loop never terminates for an empty list |
| Reproduction | Run with [] |
| Hypothesis | Exit condition assumes at least one item |
| Test | Add an empty-input check |
| Result | Failure removed; full test set still passes |
| General lesson | Test boundaries before typical cases |
The learner should become comfortable reading code they did not write—including AI-generated code—locating a failure, testing a hypothesis, and demonstrating that the repair works.
Add real development tools
A complete program should eventually include:
- a local editor or development environment;
- command-line basics;
- Git and version control;
- a repository such as GitHub;
- reading official documentation;
- package and dependency hygiene;
- automated testing;
- input validation and security fundamentals;
- responsible use of AI coding tools.
Brilliant runs Python directly in the browser, so a beginner can start without installing an environment. Independent projects should eventually move to a computer with a local editor and version control.
How Brilliant’s digital tutor Koji changes the parent’s role
A parent does not need to be a programmer to supervise this path. Koji can work inside supported coding lessons, respond to the current code or problem state, highlight relevant information, and ask guiding questions.
The parent’s responsibilities are to:
- choose the course destination and keep one coherent plan;
- protect a consistent schedule;
- review progress and help-seeking patterns;
- require original projects, tests, and explanations;
- make sure the learner is not copying finished or AI-generated code without understanding it;
- arrange human review when a project exceeds the parent’s expertise;
- keep records and work samples.
A workable week is three Brilliant instruction sessions, one independent project session, and one short review of the debugging log, code explanation, and progress. Every four to six weeks, require an unscaffolded assessment or project milestone. Use the parent progress dashboard to review activity and help-seeking patterns.
Assessment, grading, accreditation, and credit
Brilliant is fully accredited by the Accrediting Commission for Schools, Western Association of Schools and Colleges (ACS WASC). This recognizes the quality of Brilliant’s educational program; Brilliant is not a degree-granting K–12 school and does not issue diplomas, school course credit, grades, or official transcripts.
A family-created computer science record can include:
- the course title, description, dates, and planned instructional time;
- Brilliant courses and lessons completed;
- unscaffolded quizzes and cumulative assessments;
- project specifications, repositories, tests, and demonstrations;
- completed rubrics and reviewer comments;
- a debugging log and representative code;
- a grading rubric and final grade, if the family assigns one;
- standards or AP topics addressed.
Requirements vary by location and institution. Confirm what a state, umbrella program, school, college, scholarship, or athletic organization will accept before beginning if external credit matters. See Is Brilliant accredited? for the current statement.
If the goal is AP Computer Science
Brilliant provides strong foundations, but AP preparation requires the current official framework and assessment format.
A September 2026 curriculum-team-reviewed audit found 81% audited topic coverage for AP Computer Science A and 61% for AP Computer Science Principles. Topic coverage does not establish course equivalence.
For AP CSP, add AP pseudocode, the current Create performance task, computer systems and networks, computing impacts, and official question formats. For AP CSA, add Java syntax, the Java Quick Reference, Java collections and class conventions, and official AP questions.
Use How to prepare for AP Computer Science and the current College Board materials for the complete plan.
When Brilliant is a strong fit
Use Brilliant as the instruction and practice spine when the teenager:
- learns well through interactive problem solving;
- needs a structured path from programming foundations into algorithms and data structures;
- benefits from tutoring guidance at the moment of confusion;
- needs substantial practice reading, tracing, diagnosing, and repairing code;
- can also complete independent projects outside guided lessons.
Add another resource or instructor when the learner needs an externally graded course, official credit, a live class, extensive blank-editor programming, a specific language beyond Python, advanced web or application development, production engineering, or specialized support.
A strong homeschool computer science program produces more than completed lessons. It produces specifications, code, tests, debugging records, revisions, explanations, and a teenager who can decide what to build and verify that it works.
Sources and planning tools
- Brilliant coding courses
- Coding skills that matter in the age of AI
- How Brilliant’s coding coverage was audited
- What Brilliant covers for college-level coding and early software careers
- How to prepare for AP Computer Science
- AP Computer Science Principles
- AP Computer Science A
- MIT Introduction to Computer Science and Programming in Python
- Parent progress dashboard on Brilliant
