Twenty-Four Builds

The Span Lies About the Shape

Here is the headline version: Ariandel went from an empty repository to TestFlight build 24 between 1 and 10 October 2026. True, and nearly useless, because a calendar span tells you nothing about how the work was distributed inside it. So read the shape instead. Every build leaves a commit whose subject is ariandel-mobile: TestFlight build N, and git keeps the author's timestamp, so the record is right there.

Day (KST)	Builds	Count
1 October	1–2	2
2 October	3–11	9
3 October	12–17	6
4 October	18–23	6
5–9 October	none	0
10 October	24	1

Builds 1 through 23 landed in 67¾ hours: build 1 at 22:51 on 1 October, build 23 at 18:36 on 4 October. Then nothing for five and a half days, and build 24 at 07:16 on 10 October. That is a burst followed by silence. And build 24 is not even part of the burst's story. It shipped one family-wide fix (todo #363: button labels that wrapped like prose across every CWK app moved onto a shared kit control), and Ariandel was one of the apps the sweep touched. If you average 24 builds over ten days you get "a build every ten hours", and that pace never happened on any single day.

What a Round Is

Coop's history rows for Ariandel call the units of work rounds, and they are numbered two through fourteen, from build 4 to build 18. Each one has the same skeleton, and the skeleton is the method:

A trigger in Dad's words. Round five opens with him saying, right after build 7, to keep going with the next candidates. The scope is the next set of gaps against Procreate, the app Ariandel measures itself against.
Commits, one per feature, each carrying engine code, app code, tests and docs together. Round five alone landed grain and stabilization, Recolor, text spacing, Page Assist, the QuickMenu, saved selections and a gradient editor as separate commits.
The gate. A script runs the kit drift check, the engine suite, and the hosted and UI suites on a dedicated simulator. It is allowed to say no, and it did: build 13 went up on the gate's fourth run, build 14 on its third, and build 17's first two runs were blocked, once by an uncommitted file in the shared kit and once by a slider test.
A build. The family pipeline archives, uploads, bumps CURRENT_PROJECT_VERSION and writes the bump commit itself, with the source commit in its body.
A history row with fixed sections: what changed, decisions, what was verified with test counts, what was not exercised, and what shipped, fact by fact.

The engine suite grew round by round inside that loop: 57 tests at the code review, 133 at build 8, 210 at build 18. Speed without that line would have been plain speed. With it, each build was a checkpoint you could stand on.

The Review That Found the Big Bugs

The run did not start with a feature list. It started with a review. After builds 1 and 2, Dad asked for two things in order: a comprehensive code review, then the missing essentials. The review read the whole repository and found defects no test was positioned to see. The worst was the autosave. ArtworkArchive copied every painted tile's bytes on the main thread, hundreds of megabytes per save on a large painting. The fix in engine commit 6479f1f was copy-on-write tiles: freeze instead of copy, so a save shares the live buffers until somebody paints over one (Track 3 takes it apart). The same review caught merge-down running through the 8-bit display mirror, the memory-pressure hook the architecture named but nobody had written, a background save that iOS could suspend mid-write, and a canvas size that ignored device memory. All of it shipped in build 3.

Notice the order. Features at speed pile risk on whatever the first hour got wrong. A review first meant the next fifteen builds stood on corrected foundations.

Where the Speed Actually Came From

It is tempting to tell this as a story about a fast model. Be honest about the clock instead. Dad's product vision was filed around 19:00 on 1 October. Build 1 landed four hours later, and it stood on work the family had already paid for:

The delivery pipeline was not written for Ariandel. Firebrand built mobile-testflight.sh in late August, it moved into cwkSiblingKit as one pipeline for the family on 14 September, and the four-facts reader joined it on 25 September. Ariandel vendored both and supplied a twenty-line config.
The kit (born in July) carried the Pippa door, the session cookie and the shared button control. Every build commit records the kit commit it was built against.
The engine was libmypaint, measured against an alternative before a line of app code existed (Track 1). Reusing a decade of brush engineering is a speed decision.
Coop gave every round a place to report and every request a queue, which is how a family-wide request like todo #363 reached Ariandel as one stop in a sweep across every app.

A model wrote fast inside that structure. The structure is why fast writing turned into installable builds and not a pile of diffs.

Measure cadence from the record, never from the span. Count the units that actually shipped, bucket them by day, and find the widest gap. The burst and the silence are both facts, and the average hides both.

Code

A minimal sketch (compiled with swiftc and run on Ariandel's history): build cadence from git, per day and around the widest gap·swift

import Foundation

// A minimal sketch: read `git log --reverse --format='%h %aI %s'` on stdin,
// keep the commits whose subject ends in "TestFlight build N", and print the
// shape the calendar span hides: builds per day and the gaps between builds.
let parse = ISO8601DateFormatter()
var builds: [(n: Int, sha: String, at: Date, stamp: String)] = []
while let line = readLine() {
    let parts = line.split(separator: " ", maxSplits: 2).map(String.init)
    guard parts.count == 3, let range = parts[2].range(of: "TestFlight build "),
          let n = Int(parts[2][range.upperBound...]), let at = parse.date(from: parts[1]) else { continue }
    builds.append((n, parts[0], at, parts[1]))
}
guard let first = builds.first, let last = builds.last else { print("no build commits"); exit(0) }

var perDay: [String: Int] = [:]                    // the author's own calendar day
for b in builds { perDay[String(b.stamp.prefix(10)), default: 0] += 1 }
for day in perDay.keys.sorted() { print(day, String(repeating: "#", count: perDay[day]!), perDay[day]!) }

func hours(_ a: Date, _ b: Date) -> String { String(format: "%.1f h", b.timeIntervalSince(a) / 3600) }
print("builds \(first.n)-\(last.n): \(builds.count) in \(hours(first.at, last.at))")
let gaps = zip(builds, builds.dropFirst()).map { (from: $0.0.n, to: $0.1.n, h: $0.1.at.timeIntervalSince($0.0.at) / 3600) }
if let widest = gaps.max(by: { $0.h < $1.h }) {
    print(String(format: "widest gap: build %d -> %d, %.1f h", widest.from, widest.to, widest.h))
    let before = builds.prefix { $0.n <= widest.from }
    print("before it: \(before.count) builds in \(hours(first.at, before.last!.at))")
}

// swiftc -O cadence.swift -o cadence
// git log --reverse --format='%h %aI %s' | ./cadence
//
// Prints, on Ariandel at build 24:
// 2026-10-01 ## 2
// 2026-10-02 ######### 9
// 2026-10-03 ###### 6
// 2026-10-04 ###### 6
// 2026-10-10 # 1
// builds 1-24: 24 in 200.4 h
// widest gap: build 23 -> 24, 132.7 h
// before it: 23 builds in 67.7 h

Ariandel's whole contribution to the family pipeline: scripts/mobile-testflight.config.zsh, verbatim (trimmed: the app's name, project and icon lines omitted)·bash

# The binary is the app plus its engine package (libmypaint and json-c vendored inside it).
mtf_inputs=(clients/apple/AriandelMobile Packages/AriandelKit scripts/test-mobile.sh)
mtf_build_number=project-yml
mtf_watch=no
mtf_commit_subject=ariandel-mobile

# The visible version on the iPad is the product's: cwk-product.json is its one writer, and
# the archive receives it as MARKETING_VERSION. project.yml's value serves local builds only.
mtf_marketing_version=cwk-product

Exercise

Pick a project of yours that ships in numbered releases or deploys. Write down how you would describe its pace from memory ("about one a week"). Then extract the real record: one line per release with its timestamp, bucketed by day, plus the widest gap between two releases and how many releases came before it. Compare the two descriptions, and name what the average was hiding.

Hint

If release commits share a subject pattern, the sketch above works almost unchanged; otherwise use tags (git for-each-ref --sort=creatordate --format='%(refname:short) %(creatordate:iso-strict)' refs/tags). The interesting output is usually the widest gap. Ask what happened just before it.

The Span Lies About the Shape

What a Round Is

The Review That Found the Big Bugs

Where the Speed Actually Came From

Code

External links

Exercise

Progress

Comments 0