Mosaic had been leaving Notion app by app (a key for each person). This weekend the pace changed: a whole app moved in a day, by four threads working at once.
why data needs an owner
Cubes is getting ready for other people. The library is shared; a private cube and everything in it belongs to one person. Notion has no owners, so it could only ever be Selim’s. Signing in is the same story: Cubes used an API key, a secret only the owner holds. Moving means every row knows whose it is, and a phone signs in with a personal link, like the rest of Mosaic.
First came a study of the Cubes backend, of Mosaic’s earlier moves, and of how its personal links work. It found two things that would have been lost. Several Claude sessions (the daily surprise cube, the app-cube and cube-design skills) wrote Notion directly, so they had to move before production switched. And one link per account would have meant that a Cubes link ended someone’s Mosaic link. The study became a plan with nine steps, each a prompt that another thread can pick up, four of them able to run at once.
The plan in waves: three threads in the first wave, agreeing on their own.
three threads, one plan
Selim started three steps at once: “You can start with A1, B1, and B2.” One thread gave every row an owner. One gave each account a link per app, copying the old ones in so that nobody was signed out. One built Cubes’ new sign-in, with the API key gone for good. The threads agreed migration numbers by messaging each other, because the database refuses an older migration once a newer one is applied. One of them held its merge until the other had landed.
The sign-in thread held its merge on purpose, for a different reason: the app talks to production, and merging before Selim had his link would have locked him out. It tested against a faked backend, and waited for the links thread to say they were live. The words on its signed-out screen followed cube design: small letters, first person, “this phone opens cubes with my own link.”
Merging into dev also surfaced an invite recipe from another session that wrote links straight into the old place. It was updated in the same change so invitations keep working. And on the question of caution, Selim: “I am the only user of the application. That should be okay.” So the threads merged their own work.
the migration is complete
The data was copied over on dev and then on production, and the counts matched: 38 cubes, 365 pieces, 1064 placements, nothing skipped. Selim tried adding and renaming on his phone. Right after that the Notion side was removed from the code.
Then he cut four of the nine planned steps in a single message: the tools that let sessions write cubes, and the screen for inviting others. “I think we can wrap up the work. The migration is complete.” He accepted that the skills which wrote cubes into Notion would break: “I accept that at the moment. I will reconsider those setups.” The daily surprise cube was paused and the steward’s brief now says it is paused. The old tables were filed away.
It is a change of idea as much as of storage. Cubes is now an app Selim edits himself, not something sessions write behind his back. Whether those session-written parts are worth reviving he will decide later: “we will see when we really need it.”
the next app gets the same plan
A plan for the next app was written the same way that afternoon, and three of its threads were already building in parallel, agreeing class names and the order of their start-up imports by messaging each other. The notification tables had moved before them, and the todarch cube before that.
By the evening that app had switched over and its old side was gone: about 1,900 lines deleted in one cleanup. Selim had asked for it from the start, so that nothing new gets built on the old way and there is no second path to keep in mind. One last step the AI could not take: its connector can only replace all of a service’s settings at once, so removing two leftover ones stays a click for Selim.
The pattern is settling: a plan in a file, steps that threads pick up in waves, contracts agreed between the threads, and one step at a time to production while the old way stays switched on until the end.