The Software Factory

A row qualifies when it is proposed, its prerequisites have shipped and its risk class is R3 or lower. Rows for design or review work stay with me. Each slice gets four hours a try, unsaved changes in the working tree stop the run before it starts, and a slice that changes the runner's own files stops the chain until I have looked at it.

A slice that meets a question only I can answer is parked in an Awaiting ruling lane, and the chain moves on to the next row. A slice that fails because the model was not capable enough may retry one step up a short published list of models, never more than one step, and never past a model I named by hand.

The runner does not take a session's word for it. A slice counts as shipped only once its row is in the shipped register. Each slice commits its work on this machine as it goes.

The phone gets a heads-up before the chain runs out of work, a note when a closeout step ticks, and the reason when the chain stops. A fork that needs me arrives as an urgent push. Every slice records which model and effort it ran on, so I can compare what a run cost against what it was given to work with.

Which slices run and in what order, approvals, and what happens to each review finding. Since August the AI settles routine questions itself, under a standing instruction of mine, and records each ruling as mine. A question that needs me stops the slice, and in the chain that slice is set aside so the queue keeps moving.

It writes the kickoff, builds the slice, runs the checks, writes the records and suggests the next step, with one clear recommendation. In the chain it also closes each slice and commits it.

Written before work starts: what the slice will do, what is in and out of scope, the rules it must follow (quoted by ID), how success will be checked, the named checks, and a spending limit when models are involved. The closeout is judged against exactly this.

Short by rule, about 200 words: the outcome (shipped, partial or abandoned), the commits, what changed, and each check with its result. Two fields can never be left out. Manual check says what to click or run to see the result myself, and User docs says what changed in the user guide. A slice with nothing to show writes N/A and says why, and a slice that changed Studio's code cannot use N/A for Manual check.

Nine fixed steps: file the record in its phase document, update the phase index, the user guide, memory and the changelog, then move the row to the shipped register, tidy the queue, commit, restart the server if it changed, and check that the click pass can be built. The row moves near the end, because updating the docs is part of the slice. New rows are added the moment they exist, including every deferral. Since August a command drafts the four follow-up entries from the closeout record, and marks every sentence that needs me.

The reviewer's verdict is pasted into the reviewed document word for word, and every finding gets a written decision: fold it in (with the edit), reject it (with the reason), or defer it (with the row that now owns it). The AI suggests each decision. I make it.

Every review returns a verdict (GO | CONDITIONAL-GO | NO-GO), findings ranked most severe first, answers to the document's open questions, and a list of what it tried and failed to break. The verdict does not decide on its own. A NO-GO whose findings I reject can still ship, and the record says so. What the reviews have returned is on the codex page.

The real work queue, inside the roadmap. Every row has an ID, a role, a risk class and its gates, and every slice starts from a row. The roadmap page shows it in full.

Small fixes to how Studio looks and behaves, with no ceremony: an entry goes in whenever something is spotted. Screenshots attach by file name, so an entry never needs editing to gain an image. Fixes launch from Build mode one at a time or as a batch.

Changes that never reached the docs, found by comparing the git log with the changelog, then worked as ordinary doc updates.

Docs-only work moves at the speed of conversation. Work that spends money must set a limit first, and work that writes or grants power needs a written design before any code. The risk classes make that a rule, so it never rests on a judgement made in a hurry.

Every slice ends with a clear outcome and a recommended next step. The Manual check field means I can always test a claim myself, and an N/A has to come with a reason.

The documents hold the whole state of play. The AI's memory points at them and never replaces them. A new session on a new machine can pick up from the repo alone.

An author reviewing its own design shares its own blind spots. A fresh reviewer with a fixed prompt does not. Disagreements are recorded where I can see them, and I make the call.