Classes 4-5 · Year two • Mera PeakConcrete & visible

Make a bigger system remember, decide and learn.

Mera Peak keeps syntax friction low while making the systems substantially richer. Students design state, rules and reusable behavior, ask questions of data, train and test simple models, compare solutions and explain how information moves through the project.

“I can make larger systems work deliberately.”

Who owns whatThe problem and broad design are supplied; the learner increasingly owns internal behavior, state, rules, decomposition and test reasoning.

“I can build small systems with familiar logic.”

“I can design richer state, rules, procedures and model behavior deliberately.”

What changes this year

State becomes central: what the system remembers changes what it does next.
Variables represent meaningful quantities, categories, yes/no states and measurements.
Conditions become decision systems with multiple facts, priorities, overlaps and missing cases.
Custom procedures make larger systems understandable and reusable.
Students generate normal, boundary and unusual test cases.
Data work includes sorting, grouping, counting, variation and simple evidence-based claims.
Students train simple machine-learning models and separate training examples from testing.
Rule-based and learned approaches are compared rather than treating AI as automatically superior.

Still visual. Much more serious.

Try the thinking

A minute of Mera Peak thinking.

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

The system remembers. Now make it decide.

Interactive example

A larger program does not react only to what was clicked. Its behavior depends on what is true right now.

What the system remembers

weather: storm
energy: 18
supplies: 4
medicine_on_board: true

The rules — unchanged throughout

If medicine is on board AND energy is below 20 → RETURN TO BASE.
If weather is storm AND energy is at least 20 → WAIT.
Otherwise → CONTINUE.

What should the system do in this state?

What they produce

Multi-part stateful interactive systems
Decision trees / flow diagrams
Reusable custom procedures
Test tables
Data summaries and visualizations
Simple trained ML models
Rule-vs-model comparisons
User-test revisions

What you should be able to see

The state the system keeps and what changes it
Rules the learner designed or completed
A reusable behavior/procedure
A boundary or unusual test case
A simple model trained and tested on new examples
A comparison explaining when rules or a learned model worked better

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

Wildlife Rescue Command Center

A larger system combines state, explicit rules, data, a simple learned model, testing, debugging and explanation. Students receive the problem and broad design but increasingly own the internal logic and model examples.

Design archetype: Build and Test an Adaptive Smart System

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

Where Mera Peak 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: Represent richer state-and-rule processes before building and compare solutions for repeated logic, missing cases and modifiability.
Programming & representation: Trace richer state and read multi-part visual systems rather than only building from scratch.
Debugging: Find where richer state or interacting rules begin to go wrong and test one hypothesis.
Testing & reliability: Deliberately include normal, boundary and unusual cases.
Data & evidence: Sort, group, count, notice variability and question where data differences came from.
AI & machine learning: Train and test a simple model, choose training examples more deliberately and compare model behavior with hand-written rules.
Systems & architecture: Coordinate richer state, rules, procedures and components inside a larger visual system.
Technical judgment: Compare rules and learned behavior, ask which is easier to explain or change, and notice missing cases.
Security, privacy & human-centered computing: Reason more deliberately about privacy, basic security concepts, user needs and system consequences.
Explanation, transfer & technical defense: Explain how information flows through a larger stateful system and defend tests, rules, model behavior and revisions.

Open the Capability Telescope

What becomes possible next

What Lobuche Basecamp adds

Class 6 keeps the computational ideas but changes the representation burden. Students begin moving the same algorithms across diagrams, pseudocode, blocks and text code.

Enter Lobuche Basecamp

What prepared them: Mera Basecamp See the whole climb

The whole climb