A one-person operation, run as a system
Curriculum production rebuilt as a compiler, with the write permissions of its own automation treated as a safety problem.
- Role
- Owner: architecture, implementation, and operating rules
- Period
- Tutoring since 2016
- Domains
- Systems design · Build pipelines · Quality engineering · Multi-agent operations
- Artifact types compiled from one source
- 5
- Zones bounding what automation may write
- 7
- Enforcement points: write time and merge
- 2
- Source files compile to a packet object and render to five artifact types — a build system for teaching material, not a folder of documents.
- Automated writers work under a contract: seven zones, three ownership tiers, one rule — a write is authorised only by a task's own paths — enforced at write time by a hook and at merge time by a validator that reads the branch diff, so it does not depend on which assistant made the edit.
- Coverage is declared, not inferred. The decision that forced it: "The problem is not that 346 packets lack QA. It is that nothing could distinguish intentionally uncovered from accidentally invisible."
The business is the smaller half of this
Tutoring since 2016. What makes it a case study is not the teaching — it is that a service business run by one person accumulated the operational problems of a much larger one, and the answer was to build an operating system rather than to work more hours.
This case names no student, no household, no session, no invoice and no rate. Those exist and they are none of a reader’s business; what is publishable is the machinery.
The problem
Curriculum production is a document problem that behaves like a software problem. The same concept appears in a worksheet, a solution set, a reference sheet and a quick reference; a correction to one of them silently leaves the other three wrong. At a few dozen documents you can hold it in your head. Past that you cannot, and you do not find out that you could not until a student is looking at the wrong answer key.
What I built
Source compiles. Files compile to a packet object which renders to five artifact types, one namespace each. It is a build system for teaching material, and it means a fix happens once and propagates rather than being applied four times by hand.
Generated documents are checked against their sources — content hashes, numeral survival, answer-key drift, page lint. The interesting one is numeral survival: a rendering pipeline that silently drops a digit produces a document that looks perfect and is wrong.
Automated writers are bounded. Seven zones, three ownership tiers, and one rule: a write is authorised only by the paths a task itself declares. It is enforced twice — at write time by a hook, and at merge time by a validator that reads the branch diff — so the guarantee does not depend on which assistant made the edit, or on it being well behaved.
The student directory sits in the tier that is denied before the guard reads any configuration, so the rule holds even when the configuration is unreadable. That is worth stating precisely because it names a protection and never its contents.
Decision points
Decision 01Declare coverage, do not infer it
Quality coverage was the thing everyone assumes and nobody can prove. The finding, recorded at the time:
The problem is not that 346 packets lack QA. It is that nothing could distinguish intentionally uncovered from accidentally invisible.
Coverage became declared — covered, pending, or exempt — rather than inferred from whether a test happened to exist. An exempt item is a decision with a name on it. An invisible one is a hole nobody knows about, which is the same failure mode as a privacy guard that no test covers.
How we know it runs
The path contract, the declared coverage model and the source-to-artifact audits above are the guarantees; behind them sits a suite of more than three thousand automated checks, measured on 2026-08-16. That figure is evidence of breadth and nothing more — a suite size says how much was written, never what is guaranteed, and it is not an outcome. It is also not continuous integration: the gating here is local, a write-time hook and a merge-time validator, and calling it CI would be false.
One honest measurement belongs here too: a fresh checkout cannot run the full suite, because the generated corpus is absent. That is recorded as a property of the system rather than treated as a flake, which is the difference between a known limitation and a mystery.
The business behind it carries a public third-party profile with 40+ five-star reviews, read on 2026-08-01 and published through a floor so that accumulation cannot quietly falsify it. A fact about the business — never a claim about anyone’s results.