Classes 8-9 · Year one • Ama Dablam BasecampProduct & systems

Turn algorithms, data and models into a working product.

Text programming is now normal. Students receive a well-defined problem and broad architecture, then own the implementation: structured programs, data structures, algorithms, real datasets, API data, simple learned models, testing and debugging.

“I can build purposeful computational products.”

Who owns whatThe problem and broad architecture are supplied; the learner owns substantial implementation, data work, algorithmic behavior, model integration and testing.

“I can write and reason about structured text programs.”

“I can implement and explain a purposeful product that combines algorithms, data and learned models.”

What changes this year

Functions and abstraction become serious program-design tools.
Lists, maps/dictionaries, sets and nested structures are chosen for what the program needs to do.
Linear/binary search and sorting families introduce real algorithm comparison.
Efficiency begins through operation counts/runtime growth—not formal proof.
Students load, inspect, clean, transform and visualize genuine structured datasets.
Model work includes features, labels, train/test reasoning and error analysis.
A simple API introduces request/response and external data as a real system dependency.
The learner distinguishes software tests from model evaluation.

Supplied architecture. Serious implementation.

Try the thinking

A minute of Ama Dablam Basecamp thinking.

An illustrative interaction, not a lesson from the curriculum — but the reasoning is the reasoning.

Should we write the rule—or learn the pattern?

Interactive example

Two approaches can solve the same task. The mature question is not 'Which one is more AI?' It is 'Which one fits the evidence and the problem?'

The taskRecommend whether a trek route should be marked CAUTION based on wind, rain and visibility.

The eight labelled records

Wind	Rain	Vis.	Label
12	0	9	SAFE
28	1	8	CAUTION
18	8	4	CAUTION
10	6	3	CAUTION
16	1	9	SAFE
24	0	7	CAUTION
14	2	8	SAFE
20	5	5	CAUTION

The new reading

wind 22 · rain 4 · visibility 5

A human expert labelled this one CAUTION.

What they produce

Structured multi-function applications
Data-flow/system diagrams
Cleaned/transformed datasets
Deterministic algorithm explanations
Simple trained-model evaluations
API-backed features
Software tests + model evaluation
User-test revisions and limitation statements

What you should be able to see

Structured source code
A data-flow/system diagram
A deliberate data-cleaning decision
An algorithm tested independently
Model performance on unseen examples
A rule-vs-model comparison
A module the learner did not originally write but can explain/modify
A debugging record and user-test revision

Support matters. A heavily guided success is not reported as independent mastery.

Twelve Projects. One climb.

A Band is not a pile of unrelated activities. Each standard Band contains 12 Projects arranged so that capability is established, combined, transferred and increasingly owned.

P1–P4Establish / Acquire
P5–P8Combine / Extend
P9–P12Transfer / Own

Illustrative synthesis example

A data-driven decision product comparing a deterministic method with a learned model

Students receive the user, problem, data source, broad architecture and bounded model/algorithm choices. They own the implementation and must compare what the deterministic and learned approaches do well or badly.

Design archetype: Build and Evaluate an Intelligent Decision System

Illustrative synthesis archetype from current Band design; not a guaranteed final Project title.

Where Ama Dablam Basecamp lands on each capability

These are Band end-states, not lesson titles. Follow any of them across all eight years in the Capability Telescope.

Algorithms & problem solving: Use linear/binary search and sorting families, select useful data representations and begin reasoning experimentally about efficiency.
Programming & representation: Read, trace, explain, modify and debug structured programs and supplied modules.
Debugging: Diagnose wrong data types, dictionary keys, return values, stale state, API responses and train/test mismatches.
Testing & reliability: Design stronger test plans, separate software correctness from model evaluation and preserve what exact version was tested.
Data & evidence: Load, clean, transform and summarize real structured datasets; use descriptive statistics and critique visualizations.
AI & machine learning: Train simple supervised models on unseen data, inspect errors and compare deterministic vs learned approaches.
Systems & architecture: Implement within a supplied structure such as interface → logic → data/model and understand how components exchange information.
Technical judgment: Compare deterministic and learned approaches on explainability, data needs and error patterns.
Security, privacy & human-centered computing: Design for a defined user, reason about sensitive data and convenience/privacy trade-offs, and revise from testing.
Explanation, transfer & technical defense: Produce code/data/model explanations, simple diagrams, test evidence, debugging notes and a short technical presentation.

Open the Capability Telescope

What becomes possible next

What Ama Dablam Summit adds

Class 9 stops supplying as much of the system shape. The learner increasingly chooses the architecture, data structures, algorithms, model approach and reliability strategy.

Climb to Ama Dablam Summit

What prepared them: Lobuche Summit See the whole climb

The whole climb