Most students learn to make a computer do something. Fewer learn to make a computer explain something. This unit is about the second one. Students load real datasets into Python, work out what is actually in them, and build charts and short presentations that make a point a listener can follow.

It also does quiet groundwork: nothing in Phase 3 works without a student who can clean a dataset and tell whether a result is believable.

Analysis

• Reading data files into Python-usable datasets — CSV, spreadsheets, and simple APIs
• Summary views and basic statistics for a broad understanding of the data
• Filtering, sorting, and grouping to answer a specific question
• Combining tables, and handling missing or inconsistent values

Visualization

• Choosing the right chart for the question — and knowing when a table is better
• Bar, line, scatter, and distribution plots
• Labeling, scaling, and honest axes; how charts mislead, on purpose and by accident

Storytelling with data

A finding nobody understands is not a finding. Students learn to work from a question rather than a dataset, to lead with the point rather than the process, and to say plainly what the data does not show.

• Starting from a question worth asking
• Building an argument: claim, evidence, caveat
• Presenting to an audience that has not seen the data
• Being honest about uncertainty and sample size

Tools

• Pandas — loading, cleaning, and reshaping data
• NumPy — numerical work at speed
• matplotlib — turning numbers into charts that communicate

Build something real, that someone else can open. Students move from analyzing data to storing it, and from scripts that run on their own laptop to an application with a live address. Approved AI assistants are available from the first session of this unit — a deliberate choice that lets students build something genuinely useful months earlier than they otherwise could, and teaches the tool-handling judgement they will need regardless of where they end up.

The trade is that they are not deriving every line from first principles here — that comes in the summer unit, where the assistants are put away.

What they learn

• Front-end structure and styling — HTML and CSS
• Making a page respond to what the user does
• Storing and retrieving data with a database, and writing basic queries
• Connecting a front end to stored data
• Deploying to a live URL, with coach guidance the first time through
• Handling errors and unexpected input gracefully

Working with AI, properly

We don’t ban AI assistants — we teach students to use them well. An assistant that writes code a student cannot explain has taught them nothing. One they use to move faster through work they understand is a real advantage.

• Asking a specific question instead of a vague one
• Reading generated code critically — including spotting when it is wrong
• Comprehension checks: if you can’t explain it, you don’t ship it
• Knowing when reaching for an assistant will genuinely help, and when it will quietly cost them the understanding they came for

Now the assistants go away. Having analyzed real data and shipped a working application, students spend the summer going back to first principles in a typed, compiled language where the computer is far stricter about mistakes — then put that rigor to work on contest problems.

JAVA is where the understanding gets built to hold weight. It is also the foundation for both competitive programming and AP Computer Science A.

JAVA program flow (guideline)

• Fundamental data types
• Simple and nested loops
• Array manipulation
• Functions
• Simple classes and inheritance
• Simple algorithms
• Array lists
• Advanced nested loops
• Advanced functions, including recursion
• Complex classes and inheritance
• Advanced data structures — trees
• Advanced algorithms

Competitive programming

With JAVA in hand, students turn to algorithmic problem solving and prepare for the USA Computing Olympiad. The journey takes years, which is why we start early — beyond knowing a platform like JAVA or Python, the more important skill is deep algorithmic thinking.

• Reading a problem statement carefully, and checking an approach before writing any code
• Working through past contest problems together, then alone
• Entering real USACO contests, and moving up through the divisions over subsequent years

Why competitive programming

Sample USACO problem

There is no standard formula for solving these. Students learn to excel through years of developing strong problem-solving skills and algorithmic thinking.

MOO

The game of Moo is played on an N x N grid of square cells, where a cow
claims a grid cell by yelling "moo!" and writing her numeric ID in the cell.

At the end of the game, every cell contains a number. A cow wins if she has
created a region of connected cells at least as large as any other region.
A "region" is a group of cells all with the same ID number, where every cell
is directly adjacent to another cell in the same region -- above, below,
left, or right (diagonals don't count).

Cows may also pair up as teams. A team of two cows can create a region as
before, but the cells may belong to either cow. A region claimed by a
two-cow team only counts if it contains the IDs of both cows.

Given the final board, compute the number of cells in the largest region
owned by any one cow, and the largest region claimable by a two-cow team.

INPUT FORMAT
  Line 1: N (1 <= N <= 250)
  Next N lines: N integers each (0 ... 10^6)
  At least two distinct IDs will be present.

OUTPUT FORMAT
  Line 1: largest region size claimed by any single cow
  Line 2: largest region size claimed by any two-cow team

SAMPLE INPUT        SAMPLE OUTPUT
  4                   5
  2 3 9 3             10
  4 9 9 1
  9 9 1 7
  2 1 1 9

Work the way engineers actually work. From Phase 2 onward, student code lives in a real repository rather than in files scattered across a desktop. This is not a separate class — it is how every project in this phase and beyond gets handed in, notebooks included.

What they learn

• Repositories, commits, and writing a clear commit message
• Branching and merging without losing work
• Reading someone else’s code — a skill most people never practise
• Giving and receiving review comments without taking it personally
• A GitHub profile that starts filling up years before it needs to

How a model actually learns. Students train their first models on data they have cleaned themselves, and immediately run into the question that matters most: is this result any good, or does it only look good?

What they cover

• Supervised learning: classification algorithms — regressions, decision trees, random forests
• Unsupervised learning: clustering and K-Means
• Training and test splits, and why a model that memorizes is useless
• Evaluating a model honestly — what accuracy does and doesn’t tell you

Teaching a computer to see. Neural networks open up problems that classical models cannot touch — and give students something visual and immediate to work on.

What they cover

• Neural network fundamentals — layers, weights, and training
• Convolutional networks for images
• Image classification and object detection
• Working with an image dataset end to end, including the unglamorous parts

The part students already use every day — taken apart. Most students arrive having used a chatbot or an image generator without any idea what is happening inside it. This module replaces the magic with mechanics, and then has them build with it.

What they cover

• Language model fundamentals: tokens, prediction, context, and why models hallucinate
• Building a chatbot: an automated response assistant students design and test
• Prompting as engineering: writing, testing, and iterating on instructions rather than guessing
• Embeddings and retrieval: grounding a model in a specific set of documents
• Image generation: how diffusion models work, and building something with one
• Evaluation: deciding whether generated output is actually good, which is harder than it sounds
• Limits and ethics: bias, attribution, and where a generative model is the wrong tool

Students choose one direction and take it from a working prototype through to an honest evaluation of how well it actually performs — including the parts that didn’t work.

• Image-based prediction. Train a classifier on an image dataset — for example predicting a medical condition, a plant or animal species, or a handwritten digit or letter.
• Computer vision. Build an application that detects or recognizes objects in images or video, such as object detection, face detection, or motion tracking.
• Generative AI. Build a project on top of a generative model — an image generator, a style-transfer tool, a document-grounded assistant, or a system that generates text, music, or simple artwork.
• Open topic. Any other AI/ML application a student is genuinely curious about, proposed to their coach and scoped together before building starts.

By the end of this phase students are ready to conduct original research in artificial intelligence and machine learning — choosing a question, finding data, and defending what they built. Many carry this straight into a Phase 4 Science Research capstone.

A real build, on a real timeline. The capstone is not a bigger homework assignment. Students plan it, scope it, build it over several months, and present it — and things go wrong along the way, which is the point.

What every capstone includes

• A written brief the student works from — prepared by their coach, and deliberately leaving questions for the student to ask
• Regular check-ins where students report progress, blockers, and what they plan to do next
• Somewhere it actually runs — a live URL, a shareable build, or a documented notebook, depending on the track
• A live demo to peers and coaches at the end
• Documentation — a README good enough that a stranger could run the project
• A GitHub portfolio collecting this and earlier work in one place

Object-oriented programming and slick design come together here. Students design 3D games from scratch, learning the fundamentals of object-oriented programming and 3D design.

• Starting with fundamentals, students build a fully functioning game they can take home and share.
• A path into one of the most popular game development platforms used by professionals.
• Students unlock their creative potential by learning coding and design in a 3D game environment.

Students pick a topic (with guidance) for the application of artificial intelligence and machine learning. The topic requires additional research into the domain and incorporates novel modeling methodologies.

Students work the problem over multiple months to create a project presented at Science Fair — with the written work and defence that goes with it.

Students take on a community service project applying their web development skills, building on the front end, database, and deployment work from Phase 2. In the past, our students have built live websites for the City of Charlotte.

Where the stack can go

• Bootstrap and responsive layout; a deeper pass on JavaScript
• React — components, props, state, hooks, and routing
• Node.js and Express — servers, routing, and RESTful APIs
• MongoDB — data modelling, Mongoose, and CRUD operations
• DevOps — GitHub branching and merging, static and cloud hosting, domains
• How teams actually organise the work: Waterfall, Agile, Kanban