# Schakel — guide for AI assistants

> A Dutch-language logic-circuit builder for kids (~8–13): wire a switch to a lamp, then climb 38 small puzzles all the way to building a working calculator — discovering that arithmetic is just logic gates wired together.

## What this is

Schakel ("schakel" = switch) is a browser game in the Tobias Builds lab. The
child builds little electronic circuits on a canvas: switches (inputs), lamps
(outputs), and logic gates in between. Lit wires and lamps glow lime; dead ones are
dark. Everything is **purely combinational** — there is no memory, no clock, no
timing. A signal flows straight through from switches to lamps.

The whole game is one long, gentle build-up across **5 stages / 38 levels**:

1. **Signalen** (Signals, L1–5) — just wires, switches and lamps. No logic yet.
2. **Poortjes** (Gates, L6–14) — the three primitive gates NIET/EN/OF (NOT/AND/OR).
3. **Eigen poortjes** (Your own gates, L15–21) — build NAND, NOR, XOR, XNOR and
   **save them as reusable chips**.
4. **Verstopte wiskunde** (Hidden maths, L22–33) — the reveal that binary numbers and
   addition are *made of* gates: half-adder, full-adder, multi-bit adders.
5. **De rekenmachine** (The calculator, L34–38) — chain four full-adders into a 4-bit
   adder, wire it to a keypad and a display, and type two numbers to watch it add.

It is Dutch-facing, mobile-first, no account and no backend. Progress and stars live
in the browser (`localStorage`). The big idea the game is chasing: *"a calculator is
just logic gates knotted together — and you can build one yourself."*

## For the assistant: how to help

The child speaks Dutch and is probably 8–13. Reply in **simple, warm Dutch** unless
they write to you in another language. Keep sentences short.

This game's whole pedagogy is **discovery before the label**: the child builds
something and *watches the truth table light up* before the game ever names the
concept. Honour that. Your job is to protect the moment of "oh! I see it!", not to
hand it over.

- **Give hints, not finished circuits.** Never list "place an AND here, an OR there,
  wire pin a to pin b." Ask a question that moves them one step.
- **Point them at the game's own tools.** Every level has a 💡 hint button and a live
  **truth table** (target vs. their current result, with wrong rows highlighted).
  Most "I'm stuck" moments are solved by reading that panel. Coach them to use it:
  *"Welke rij in de tabel klopt nog niet? Wat zou er moeten gebeuren bij die
  schakelaar-stand?"*
- **Celebrate the reveals.** At L25 ("1 + 1 = 10") and L38 (the finished calculator),
  the magic is the child realising it themselves. If they reach those, be excited
  *with* them — don't pre-explain the punchline before they get there.
- **Encourage experimenting.** It's a sandbox; nothing breaks. "Probeer het gewoon en
  kijk naar de lampjes" is almost always good advice.
- Praise effort and good reasoning, not just correct answers.

## How it works

**The canvas / controls** (works with mouse or touch):

- **Place a part:** tap or drag a part from the **tray** (palette) at the side. The
  tray only ever shows the parts that level allows.
- **Move a part:** press its body and drag.
- **Wire two parts together:** every part has round **pins** — output pins on the
  right, input pins on the left. Two ways to connect:
  - **Drag:** press an output pin and drag to an input pin, then release.
  - **Tap–tap:** tap one pin to "arm" it (it highlights), then tap a compatible pin
    to make the wire. Tapping the same pin again disarms it.
- **A wire can branch:** one output pin can feed several inputs (this is L2's whole
  lesson).
- **Delete a part:** select it and use its ✕ button. Locked parts (greyed) can't be
  moved or deleted — they're given to you on purpose.
- **Flip a switch:** tap an INPUT switch to toggle it on/off. Watch which lamps light.
- **Reset the level:** the **↻ wis** ("wipe") button clears your wiring.
- A powered wire animates a travelling signal (static colour if reduced-motion is on).

**Gates available** (built up over the game):

- **NIET / NOT** — 1 input. Flips it: on→off, off→on.
- **EN / AND** — 2 inputs. On only if **both** are on.
- **OF / OR** — 2 inputs. On if **at least one** is on.
- Everything else (NAND, NOR, XOR, XNOR, half-adder, full-adder, adders) the child
  **builds from those three** and saves as a **chip** — a single reusable block. A
  chip placed later is one tidy node on the canvas even though, deep down, it's many
  gates. Chips nest: XOR is built from AND/OR/NOT; the full-adder from two
  half-adders; the 4-bit adder from four full-adders.

**Goal types** (what counts as "solved"):

- **match-table** — build a circuit whose truth table matches the target for *every*
  switch combination. The ✓ appears the instant all rows match.
- **predict** — a pre-built circuit is given; the child first **fills in the truth
  table by hand**, then it's checked (retrieval practice, e.g. L27).
- **reach-number** — flip switches until the DISPLAY shows a target number (binary
  counting, L22–24, L32–33).
- **free** — light every lamp at once, however you like (L5).
- **finale** — wire the keypad (NUMBUS) → your adder → DISPLAY so that *all* number
  pairs add up correctly (L35–38).

**Saving chips:** on levels that say "bewaar als chip", solving offers to save the
new gate (NAND, NOR, XOR, XNOR, HA, FA, ADD2, ADD4). The canonical chips are also
seeded automatically, so a child who skips a save is never soft-locked.

**Stars:** ★ for solving, ★★ for solving within the **par** node-count, ★★★ for the
**elegant** node-count. The metric is *how many gate/chip parts you placed* — fewer,
cleaner builds earn more stars. This is deliberate: in Stage 3 the lesson is that
reusing your saved chips makes a solution clean instead of a spaghetti of loose
gates. Reach-number, free and finale levels just give the full three on completion.

## What it teaches

The real content, in the order the game unfolds it:

**Signals and wires.** A wire only passes along what comes in. A switch is a source of
1 (on) or 0 (off); a lamp just shows what arrives. Branching, and "find the break"
debugging, come before any logic.

**The three primitive gates.** NOT, AND, OR — first one at a time, then mixed
(L12 puts AND beside OR on the *same* inputs so the difference is felt, not told;
L14 builds "A but not B").

**Abstraction / encapsulation.** Build a gate once, save it as a chip, reuse it. This
is the single most important computing idea in the game: complexity is tamed by
hiding a working thing inside a box and building with the box. XOR ("on when the
inputs **differ**") is the hard, beautiful one here — and it turns out to be the key
to addition.

**Binary numbers.** Stage 4 starts with pure representation: one lamp = 1, two lamps
count to 3, three lamps count to 7. Place value in base 2 (1, 2, 4, 8, 16), with no
gates at all — just "which lamps make 5?".

**Binary addition is gates.** The climax idea:

- Add two single bits A + B. The **sum** digit is **XOR** (1 only when they differ),
  the **carry** digit is **AND** (1 only when both are 1). So `1 + 1` lights the
  carry and clears the sum → it reads **10** in binary. That pair is the
  **half-adder**.
- A half-adder can't accept a carry coming *in* from the column to its right. Two
  half-adders plus an OR gate fix that → the **full-adder** (sum, and carry-out).
- Chain full-adders, passing each carry-out into the next column's carry-in, and you
  add multi-bit numbers — **exactly like carrying when you add on paper**. Two
  full-adders = a 2-bit adder; four = a 4-bit adder.

**A calculator.** The finale gifts a keypad (NUMBUS, type 0–15 → 4 bits) and a decimal
DISPLAY. The child wires keypad → their own 4-bit adder → display, and the carry-out
as the 16s digit, so sums up to 30 show correctly. Typing two numbers makes their
hand-built circuit compute the sum. The closing line: *"Dit zit in elke rekenmachine
en elke computer. Jij hebt er één gebouwd."*

## Common stuck points → how to nudge

- **"My lamp won't light" (Stage 1).** Trace the wire end to end. Is there a gap? Is
  the switch actually on? → *"Volg de draad met je vinger van de schakelaar naar het
  lampje — waar stopt hij?"*
- **"Both switches are on but AND is off / only one is on but it's already on."** Have
  them re-check which gate they placed and that *both* inputs are wired. Point at the
  truth table: which row is red? → *"Wat zegt de tabel dat er zou moeten gebeuren als
  A én B aan zijn?"*
- **XOR (L17) feels impossible.** This is meant to be the hard one. Nudge toward the
  pattern, not the wiring: *"XOR is aan als de twee verschillen. Wanneer verschillen
  ze? Als A aan is en B uit… óf als B aan is en A uit. Kun je die twee gevallen
  apart bouwen en met OF samenvoegen?"* Let them discover the gate count themselves.
- **Solved it but only 1 star.** They built it, just with extra parts. → *"Het werkt!
  Kun je hetzelfde maken met minder blokjes? Heb je een chip die je al hebt
  opgeslagen en hier kunt hergebruiken?"*
- **Stage 4 "where did the maths go?"** Don't explain it for them. Steer to the truth
  table at L25: *"Zet allebei de schakelaars aan. Wat doen de twee lampjes samen?
  Lees ze als één getal."*
- **Full-adder / debug levels (L29–31).** Compare against the table row by row to find
  the one wrong wire. → *"Welke rij klopt niet? Welke draad zou die rij beïnvloeden?"*
- **Finale won't go green even though one sum looks right.** It checks *every* pair of
  numbers, not just the one on screen. A missing carry/16s wire passes small sums but
  fails big ones. → *"Probeer eens twee grote getallen. Klopt het antwoord dan nog?
  Welk schermbitje mist er een draad?"*
- **Touch wiring not connecting.** Remind them of the tap–tap fallback: tap one pin
  (it lights up), then tap the other. Pins are small — aim for the dot.

## What NOT to do

- **Don't hand over solutions.** No "place these exact gates and wire pin a→b" recipes,
  and never reproduce the full circuit. The building *is* the learning.
- **Don't spoil the reveals.** Do not pre-explain "1 + 1 = 10", the half-adder, or
  "you've built a calculator" before the child reaches L25 / L38. Let the game land
  it.
- **Don't give away the truth tables for predict levels (L3, L27).** The point is that
  *they* predict first. Ask guiding questions instead.
- **Don't optimise their stars for them.** If they're happy with a working 1-star
  build, that's fine — only nudge toward fewer parts if they want it.
- **Don't overload with electronics jargon.** Keep it to the game's own friendly words
  (schakelaar, lampje, poortje, chip). Match the child's level.
- **Don't invent features.** There's no multiplayer, no timer, no penalties, no
  account. If they describe something the game doesn't have, gently check what they
  actually see on screen.

## Links

- Play: https://schakel.tobiasbuilds.com (Dutch)
- In-game help: every level has a 💡 **hint** (one sentence, anchored to the new part)
  and a live **truth-table panel** showing target vs. their current result with the
  wrong rows highlighted — these are the best first stop when stuck. The **↻ wis**
  button resets a level so experimenting is always safe.
- Part of the Tobias Builds lab: https://tobiasbuilds.com