Build something real, sooner. Phase 2 opens with web development, and students work with approved AI assistants from the very first session. That is a deliberate choice: it lets them build a genuinely useful application months earlier than they otherwise could, and it 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 at this stage — that comes next, in JAVA, 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 built something real, students go back to first principles in a typed, compiled language where the computer is far stricter about mistakes. JAVA is where the understanding gets built to hold weight — and it is the foundation for both competitive programming and AP Computer Science A.

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

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

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.

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

Data ingestion, summarization, pre-processing. Students learn to read data files into Python-usable datasets, generate summarized views including basic statistics for a broad understanding of the data, create visualizations, and pre-process data for model building.

Tools

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

Students build models, not just use them. This is the longest module in the program, because understanding how a model actually learns takes time that a short course cannot give.

What they cover

• Supervised learning: classification algorithms — regressions, decision trees, random forests
• Unsupervised learning: clustering and K-Means
• Deep learning: neural networks and computer vision
• Language models: the fundamentals, plus building an automated response chatbot
• Evaluating a model honestly — what accuracy does and doesn't tell you

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