Some time in June I was scrolling TikTok the way you do when you have decided not to study, and a video came up about a "system design roulette": a wheel of topics, you spin it, you get a topic, you have to talk about it for a few minutes. It was a party trick for interview prep. What I saw was a forcing function. I had been telling myself for a year that I would practise system design "once things calmed down", and things had not calmed down, and the wheel did not care.
So I built my own. Not a wheel on a web page: an app that takes the screen.
The roulette
The first version was called System Design Roulette and it did one thing with no mercy. Once a day, at a time I set, a launchd agent opened a full-screen window above the menu bar. It asked three questions about yesterday. It spun a wheel across seventy-two concepts I had unlocked. Then it wrote a thirty-minute course on the topic it landed on, on the spot, by shelling out to the coding agent I already paid for, and it did not let go of the screen until the check at the end was done.
System Design Roulette, June. The screen that stayed until the work was done.
It was a Tauri app with a Rust core and Svelte screens drawn as system-topology diagrams, because if the app was going to hold my laptop hostage it might as well look like a control room. Content came from Claude Code headlessly, with Codex as a fallback and a few bundled courses as the floor, so it needed no API keys and worked offline. I shipped 0.1.0 on the fifteenth of June and it taught me system design every morning at 06:40 for the rest of the summer.
The wheel, drawn as a leader election across shards. This morning it landed on consistent hashing.
I was proud of the lock. That was the point of the thing: a lesson you cannot swipe away. I put three strictness levels on it, the strictest of which blocked Cmd+Tab, Force Quit, logout and shutdown while a lesson held the desk. I gave it an escape hatch, a long phrase you had to type. I gave it a release token, a file you could create to disarm it. I thought I had been careful.
The laptop
A colleague asked to try it. I sent him the repo; he pulled it, ran it with the dev server, went through the setup, picked the strict level because of course he did, and set a study time for a few minutes later so he could see it work.
The window came up. It was white. The lesson had failed to generate, the interface had not drawn anything, and the kiosk had engaged anyway, because the kiosk did not know or care whether there was anything to show. The escape hatch lived inside the window that was blank. The release token had to be created from a terminal, and the lock did not allow a terminal. Force Quit was blocked, logout was blocked, shutdown was blocked. He had a white rectangle above his menu bar and a machine that would not do anything else.
He held the power button, rebooted, and the launch agent brought the white rectangle back before he could reach the dock.
He got out by booting into Recovery Mode, opening Terminal from there and deleting the launch agent file from his own home folder. Then he came back to my desk and, to his enormous credit, was more amused than angry. I was not amused. I had built a thing whose whole promise was "you cannot get out of this", and I had not asked hard enough what happens when the thing itself is broken.
Doubling down
The obvious move was to soften the lock. I did the opposite, because a lesson you can dismiss is a reminder, and I already had reminders. What I changed was the contract around the lock. The kiosk would never engage until the interface had reported that it had drawn something. The release token would work from any mounted volume, so a USB stick by the desk was a key that needed no terminal. A lock would let go by itself after three hours, whatever the app believed. And the escape phrase moved out of the window that might be blank and into a place that would exist even if nothing else did.
That rule, a lock must always be escapable without a terminal, went into the repository as a sentence, and later into the contributing guide, and every release since has been held to it. Much later it produced the recovery console: a key combination the operating system registers, not the page, that opens a small terminal above every window, even a locked one, where four commands in order end the session, and five presses in ten seconds end it even if the console itself cannot open.
Settings › Recovery, today. The combination, the four commands and a walkthrough, kept where they can always be read.
Then I used the app for a while, and then I stopped. Not because it was bad. Because it did one subject, and I had learned the thing I had built it to learn, and the wheel had nothing left to land on that I had not seen. It sat in the dock. I shelved it.
Another colleague
Another colleague, with the same itch, had pulled the repo and explored it further than I had ever intended anyone to. A couple of months later he asked what had happened to the thing that had bricked the other colleague's laptop. I told him it was on the shelf. He said the lock was interesting but not the main part of it. The main part was that the app had written him a decent course on consistent hashing in four minutes from the agent he already had, with the sources cited, and then checked whether he had understood it. Why, he asked, was that only for system design? Why not Bash, or TypeScript, or German?
I had not thought of it as a platform. He had. And he did not just suggest it: over one week in September he sent the commits that turned the roulette into classrooms. Classroom subjects with their own prompts. CEFR language programmes with scenarios and passes. Research grounding, so a lesson was written from pages the app had actually fetched from a course's allowed documentation hosts rather than from a model's memory. An in-course chat with the tutor, exercises with a workspace, a reproducible DMG bundle, and a pile of refactors that made one shared runtime possible where there had been two. Eleven commits, most of them large, all of them the kind that makes the next fifty possible.
Taking it from there
From there I took it to the first stable version, 0.2.0, with installers for macOS, Windows and Linux, and the product got a new name, because it was no longer a roulette. Principia Desk: understand deeply, practice daily.
Principia Desk. The countdown to the next class, the study pulse, and the week's appointments.
The shape now is classes. Nine of them, from Linux Bash to Italian, each with a curriculum of topics that carry an outcome, the mechanisms, a production scenario, the misconceptions and two or more primary sources. You choose a starting point per class: from scratch, a stage you declare with the topics you already know, or a placement check that samples every stage three times so no stage is skipped on a lucky answer. You add study times, each weekday with its own start and length. Twenty minutes before a study time the desk plans the next topic on your route, fetches the sources and writes the lesson, and it rings only when the lesson is actually ready. The lesson is sized to the minutes you gave it, point form with reading hints, a practice stepper, a check whose questions are grounded in what you just read. What did not stick comes back as retrieval on a later day.
A thirty-minute lesson on CAP, sized to its study time: the stepper, a reading hint per section, the rail that stays in view.
The lock is still there. It is a policy per class now, advisory, focused or strict, and it has five documented ways out, and the README lists all of them including the ones for a build so broken it cannot draw a window. That paragraph exists because of an afternoon in June.
The last piece landed this week: classes of your own. You write what you want to be able to do, in a sentence, and the tutor drafts the whole curriculum, four stages and a few dozen topics with sources, held to the same validator as the bundled ones. You edit it on cards until it reads right, the tutor reads it back and tells you what is wrong, the desk fetches every source, and you enrol. I wrote the first one for Rust command-line tools, which is the subject I have been telling myself I would get to once things calm down.
A class of your own at the review step: the four stages the tutor named, a card per topic, the checks on a rail.
What I would tell myself in June
Three things.
The forcing function was right. Every good thing in this project came from the decision to build something that does not ask. Softening it would have produced one more app I meant to open.
A lock is a promise about the machine, not about the lesson. The question is never "how strong is the lock", it is "what happens when the thing holding the lock is itself broken", and the answer has to be written down before the first person installs it. The bricked laptop was not a bug in the kiosk; it was a missing sentence in the design.
And show it to someone who will install it, not someone who will nod. Everything the product is today, from the classes to the languages to the rule about the lock, came from two colleagues: one who was willing to put it on his own laptop, and one who pulled the repo anyway after seeing what it had done to the first, and came back with a bigger idea.
Principia Desk is free and open source, MIT, at dark-matter08/principia-desk; the site is principia.ndelucien.com. Bring your own tutor. Keep a USB stick by the desk.
Comments
No comments yet.