The cube problem: things belong to several groupings at once, and every tool makes one of them the master. A post is a colour, a voice and a period at the same time; a memory is a place, people and a feeling. Cube design is the search for a language that keeps all the axes, and lets you turn between them.
big steps
- 8 Nov 2026: cube screens keeps only today’s understanding; every red a regression finds in any app is fixed once in the package (0.16.0 to 0.19.1); the documentation sites publish from a release branch, not on every commit (fixed once, for every app, shared is not published)
- 7 Nov 2026: cube screens graduates: the angular package, the screen guide, the violations and the regressions move out with their history to a home, a website and a team of their own, and cube design keeps a tile that leads out; under the every-level prototype, the cube’s physics: what a thing is stays fixed by where it was added, a grid of seven places by six moves, rounds three and four built against it, and an agent sent to break it (the first graduate, the physics underneath); in the evening the physics is let go for a typed schema that grows with the person, with rules for changing a type and a picture type, in the shared package the same evening (a schema that grows with the person)
- 6 Nov 2026: round two of the every-level prototype: the app waits for the first group, then reads a piece by what fills it (a way of looking, a table of its own, or nothing); one add; three things Selim met turned red, then green; by the evening every level is the base study, a conformance reviewer tries to break it, things gather only when a way of looking is found, add stays last, and every tile is one size on every screen (read by what fills it)
- 5 Nov 2026: the cube screen problem said as one doing at every level; a model, its use cases and its screens built in parallel into a page to play (the same doing, one level up)
- 5 Nov 2026: cube design 0.5: a thin core said only in pieces, cubes and parts, and six applications where it is applied; the screens’ notebook moves to a repo of its own, old versions become tags, and a shared catalog of regression cases begins (a thin core, red first)
- 4 Nov 2026: the first cube is the fixed one; the plus opens a level of its own; an empty group gets room, not one giant add; the library gets a headless report kit and every context cube a last part, tell us (stability and flexibility, one pool)
- 4 Nov 2026: prototypes are built on the library itself; a gap in the grid is fixed once, in the package, for every app (data, not actions)
- 3 Nov 2026: shape waits for the person’s sign, and discovery offers and never places; cube design gets its own loading look and a pinch that steps one level, built once in the library and taken by three apps (only the person knows, once, in the library)
- 3 Nov 2026: cube design’s rules are written once as a Java kit, built in five steps and tried against three real apps; one piece in many places becomes a requirement every app meets, solved once (one kit under every backend, one piece in two places)
- 3 Nov 2026: the design gets a memory: 46 use cases for an app that starts empty, a runner that plays them on every prototype, and three prototypes tried against them, so a fix can no longer quietly lose an earlier answer (a memory for the design)
- 3 Nov 2026: cube design is pulled apart into three problems (grouping what is given, things that share a shape, finding the shape while adding), and grouping is solved alone first, with every grouping case holding (the key became a door)
- 2 Nov 2026: cube design 0.4, one thing and three words, principles against guidelines; the apps are fixed against the navigation run in parallel; the Angular package gets a docs site built with itself; and the design is read below the screen for the first time: layers, 22 database checks and 5 backend checks that run as one command, and the design of a backend library that would hold the shape once (below the screen)
- 1 Nov 2026: the hold, the icons, the model and the square of the context cube move into the shared Angular library early, and cube design itself is cut down to one version around the piece and its roles (one person, many agents)
- 31 Oct 2026: cube design is checked against itself and the four apps for the first time: 81 assertions, navigation walked in every app (checking the design against itself)
- 31 Oct 2026: the word part (a piece is the thing, cube and part are its roles), turning rows, one hold menu, and the cube drawing shared by every app as one package (taming the chaos)
- 30 Oct 2026: small letters first, language is its own piece, faces are always a complete square, two fingers step out, and a new piece that keeps the violations on show, the first one fixed before lunch (the words become theirs, keeping the mistakes on show).
- 29 Oct 2026: taken out of the apps into a repository of its own, with a skill every agent can load; Mosaic and Anlat start following it. Its changes are logged and shown in Mosaic, and it moves into Cubes as a cube. The search for words runs through ten domains, and the many-to-many loop becomes an open question (cube design moves into a cube).
- 28 Oct 2026: named. A vocabulary (piece, dimension, option, cube, look) and the moves on it (collect, notice, distinguish, rotate, zoom). Selim’s turns: discovery starts when two things are the same, and the end of the recursion “is what we are at this moment”. The cube is the viewfinder, not the data. The same day it showed up in Mosaic’s home, in Anlat and in Cubes (the cube that kept showing up).
- 27 Oct 2026: two apps turn out to share one idea: Anlat’s ways of looking and the to-do app’s lenses (when the tiles start talking).