One rung at a time

The Portal — the learning platform this course builds — is not delivered in one go. It is climbed: one rung, then the next. A rung is one accepted increment of the Portal: a thin slice sharpened by the Operator, built and shipped by the Author, demoed and reviewed by the Operator, and closed by feedback that edits the spec (the A1.03 loop). Nothing about the Portal lands except as a rung, and no rung lands until it is accepted.

So the Portal is never half-poured. It is exactly as tall as the last accepted rung — always running, always provable up to where the climb has reached. The hero figure runs one rung through the loop: the branded-id rung, six stages, each with one owner and one output. Step it to follow the turn from a sharpened slice to an accepted increment.

One rung at a time would be slow if each rung started over. It does not. Each rung adds to a platform that already runs: the store lands, then the engine behind one facade, then the Phoenix web app, then the Telegram bot, then the student dashboard. Each surface stacks onto the one before. The engine stays behind a single facade the whole climb — new surfaces call it, they do not multiply it.

Step the figure to add rungs one at a time. The readout shows the platform growing — the surfaces that are now live — while the facade count stays one and the concepts from earlier modules stack: the id authority from A1.06, the loop from A1.03, the spec from A1.04. The Portal accumulates instead of resetting.

Take the first rung concretely: branded ids. The Operator sharpens the slice — a typed id, 14 characters, decodes to its type — and fixes what “done” means. The Author specs it, builds Portal.ID.generate/1 from the spec and the brief, and ships it so it runs. The Operator demos it (mint an id, decode it, read .type), reviews it against the spec, and feedback closes the turn by editing the spec the next rung starts from.

That one rung is the store. The next rung — the engine behind one facade — is added the same way, and it calls the id authority the first rung established; it does not re-mint its own. Web, bot, and dashboard follow, each one rung, each calling the engine through its single facade. A rung is accepted only once its checks close — a property a later page will name correct by definition — and the climb moves up by exactly one accepted rung at a time.

# Rung 1 — the store: branded ids, minted and read only through the authority.
id = Portal.ID.generate(:user)        # => "USR0NbAb1xcFCy" (built to the spec)
assert Portal.ID.decode(id).type == :user   # the review accepts to the spec

# Rung 2+ — engine, web, bot, dashboard each ADD a surface onto the running platform,
# calling the engine through its one facade. The id authority above is reused, not re-minted.
# The Portal is exactly as tall as the last accepted rung; the facade count stays 1.

The Portal is climbed, not poured: one accepted rung at a time, each a thin slice run through the Author/Operator loop — sharpened, built, shipped, demoed, reviewed, closed by feedback. The rungs accumulate onto a platform that already runs, and the engine stays behind one facade, so the project grows instead of resetting. A0 named the artifacts; A1.01–A1.05 named the unit, the principles, the loop, the two layers, and what “done” means; this module made the project concrete. That resolves A1.06: the Portal is the running project the rest of the course builds, one provable rung at a time. The module overview lists the dives that built this picture.

Primary sources for building in thin, provable increments, and where the climb connects in the course.