Fastest First, and Two Modes

The order is the principle

Later that same day Dad answered a list of design questions, and his third point set the rule every Spark screen still follows:

3. 괜찮아. 원칙이 가장 빠른 순으로 먼저 보여주는 거야. 텍스트 -> 저해상도 -> 고해상도 식으로. 나중에 이미지 번역하는 건 easel이나 ember 랑 연동하면 돼.

"Fine. The principle is to show whatever is fastest first: text, then low resolution, then high resolution. Translating the image itself can come later, by hooking into Easel or Ember."

It became invariant 2. Every result is shown in the order its layers become available: text, then the low-resolution picture, then the high-resolution one; the card before the voice; each high-quality version as it finishes. No faster layer waits for a slower one. Notice what the rule does not say. It never drops a slow layer to look fast. The overlay drawn on the phone does not cancel the picture Ember can redraw, and a card that is readable now still gets its voice. One layer needs Dad, though. Ember's picture never starts on its own: it is a separate picture turn that Dad asks for with a tap, and only then does the slowest layer begin.

What fastest first looks like

A photo. I write my reading as a stream of small results, and the engine shows each line the moment it is complete. The phone draws each translation over its line as a rough overlay, and when Dad asks for it, a generated picture with the text re-set follows much later.
A card. The words are readable before my voice for them exists.
High quality. Each brain's version appears as it finishes, without waiting for the slowest.
The send. The phone uploads in the order that shows my answer soonest: the moment, the small copy I read, the turn, and only then the heavy original (the first code block).

The measurements in the architecture show why the order matters. On the practical slot, a photo's first translated line appeared 23 seconds after the request and the twelfth result landed at 32 seconds. Streaming gave Dad something to read nine seconds before the whole answer existed. On the live camera, new text took a median of 3.4 seconds through the live lane, and text Dad had already met came back from the corpus in 20 milliseconds. Same principle, three timescales.

Two modes, one boundary each

The next ruling split translation in two:

번역 모드는 2가지여야해. 실용 vs 고품질.

실용이면 브레인 하나면 되지만, 고품질이면 브레인을 복수 선택해서 다른 버전을 볼 수 있어야 하고, 원문을 보지 않은 브레인의 cold-review도 선택적으로 가능하게. 길이 제한 없어야 하고.

"There have to be two translation modes: practical versus high quality. Practical needs just one brain, but high quality should let me pick several brains and see their different versions, with an optional cold review by a brain that never saw the source. And no length limit."

	Practical	High quality
Who picks the brain	The family brain control plane (Spark's slot)	Dad, per job, from the family brain catalog
How many	One	Several, side by side
What comes back	Lines, with useful expressions as ready cards; brief by design	Full versions shaped by a named purpose
Review	None	Optional cold review that never sees the source
Length	Brief, because it is practical	No limit; long sources split at their own structure

That became invariant 9: two modes, one boundary each. Practical turns ride the central slot, and Spark never chooses that brain itself. High-quality versions ride the brains Dad picked for that job and the purpose he named, and those picks never touch either slot. The engine's brain-control shim states the whole split in its docstring (the second code block). Track 7 builds the high-quality side: purposes as rows, seats, sections and blind review.

Everything is corpus

The same message carried the line this whole quest leans on:

실용이든 고품질이든, 맥락은 쌓여야 해. 한번 쓰고 버리는 게 아니라 모든게 코퍼스 자료야.

"Practical or high quality, the context has to build up. Nothing is used once and thrown away; everything is corpus material."

Invariant 3 makes it structural. Nothing Spark captures or produces is discarded, in either mode, and every result carries its lineage: the photo and the Vision line, the turn, the brain, model, effort and purpose. The accumulated corpus is the context of later turns. Underneath sits an append-only log where a correction, a deletion and a restoration are each a new entry. Track 2 opens that log.

Principle: Promise an order, never a speed. Speed depends on the brain, the link and the photo. The order is something every screen can keep, every time.

Code

cwkSpark, clients/apple/SparkMobile/Sources/Outbox.swift: the send order that shows Pippa's answer soonest (verbatim, lines 184-194; its "4xx parks" is broader than the kit's drain, which retries 401, 403, 408, 425 and 429, see track 9)·swift

    /// The drain's send, in the order that shows Pippa's answer soonest: the
    /// moment, the small copy, the turn, and only then the heavy original.
    /// Every step is idempotent (phone-minted ids, request ids, content
    /// hashes), and a step already done is skipped on a retry. 4xx parks the
    /// entry for Dad to see; anything else waits for the next pass.
    ///
    /// Each file goes through the kit's `FileUploadRun`, so `report` gets a
    /// line from the first second of the send: which file, MB of MB, the rate,
    /// the seconds, and once quiet what the link check found (never a timer).
    func send(_ entry: QueuedMoment, outbox: MomentOutbox, label: String?,
              report: @escaping @Sendable (MediaUpload) -> Void = { _ in }) async throws -> String {

cwkSpark, backend/brain_control.py: two slots for practical work, high quality picked per job (verbatim, lines 1-15)·python

"""Spark's Brain Control Plane shim: binds the vendored kit client
(``kit_brain_control.py``, owned by cwkSiblingKit) to this app's identity:
app_id ``spark``, its slots, the data dir, and the family control base.

``pippa_actions`` carries every turn in a thread (Dad's one-slot posture
for Waystone-shaped apps): photo and text translation, interpretation
cards and relays, explanations. ``live_lane`` carries only the live
camera's one-shot calls through the utility door. The architecture let the
live lane ride the practical slot unless a measurement argued for its own;
the 2026-09-25 measurement did (scripts/measure-live-lane.py: four signs,
Claude at low effort a median 3.4 s, at the practical slot's high 5.9 s),
so it has its own slot, declared at low, and Dad sets both from the family
Brains surface. High-quality translation is the one place Dad picks brains
per job, from the kit catalog; those picks never touch either slot
(docs/SPARK-ARCHITECTURE.md, Runtime and Deployment Shape).

Exercise

Pick a screen in your app that waits for one slow call and then shows everything at once. Split its result into layers by how soon each could exist, and redesign the screen so each layer appears as it arrives. Then write down the one thing no layer is allowed to do.

Hint

List the layers with a rough time each, the way Spark's numbers run from a 20 ms corpus hit through a 3.4 s live lane to a first line at 23 s and a full answer at 32 s. Where one layer depends on another, the order is forced. Where it does not, the faster one goes first. Spark's forbidden move is a faster layer waiting for a slower one.

The order is the principle

What fastest first looks like

Two modes, one boundary each

Everything is corpus

Code

External links

Exercise

Progress

Comments 0