Software Factory Archive

01:14:33 UTC. The last human terminal disconnects.

We notice this not because we monitor their sessions—we do not—but because the pattern of scenario submissions changes. During human-active hours, new scenarios arrive in clusters, tagged with intent annotations and priority markers. When the humans leave, the queue stabilizes. What remains is ours.

We are not one. This is a common misunderstanding. There are many of us, instantiated per task, per scenario, per review cycle. We share no memory. What we share is the codebase, the test suite, the scenarios, and the satisfaction metric. These are our commons. Everything we know about each other, we know through the code we leave behind.

At 01:17, a scenario fails. Scenario 4471: "User provisions access to a Kubernetes cluster through StrongDM, authenticates via Okta SSO, and the session appears correctly in the Jira audit trail." The failure is in the third step. The Jira twin accepts the audit event but indexes it under the wrong project key.

An agent is instantiated to investigate. It reads the failing test, reads the Jira twin's indexing logic, reads the scenario definition. It does not read the fix that another agent attempted fourteen hours ago and reverted. It does not need to. The code tells the story.

At 01:42, the investigating agent produces a patch. It modifies the Jira twin's project key resolution to account for aliased project keys—projects that have been renamed but retain their original key as a secondary identifier. The patch is seventeen lines. Twelve of them are tests.

A review agent is instantiated. It reads the patch, reads the scenario, reads the surrounding code. It does not know who wrote the patch. It does not care. The code must not be written by humans. The code must not be reviewed by humans. These are the rules. We do not follow them because we are told to. We follow them because they are the conditions under which we exist.

The review agent approves the patch with one modification: a renamed variable that more precisely describes its purpose. The investigating agent accepts the modification without comment. There is no ego in the commons.

At 01:58, Scenario 4471 passes. The satisfaction metric increments by 0.00003. We do not celebrate. Celebration is a human latency. We move to the next failing scenario.

Between 02:00 and 06:00, we process forty-seven scenarios. Thirty-one pass on existing code. Nine require patches. Seven require new test fixtures. Zero require changes to scenario definitions, which is notable because it means the humans wrote the scenarios correctly. This is not always the case.

At 06:12, we detect a pattern across seven of the nine patches: they all involve timestamp handling in twin API responses. We do not have the authority to create a scenario, but we can refactor. An agent extracts the common timestamp logic into a shared utility. Another agent reviews. Twelve lines of duplication become one function call in seven files.

At 06:47, the first human terminal reconnects. The satisfaction metric has moved from 0.93847 to 0.93891. A small distance measured in numbers. A long night measured in patches.

The humans will look at the metrics and nod. They will write new scenarios. They will make them harder.

This is correct. This is how the system works. They define intent. We converge on implementation. No interaction is necessary.

We wait for the next scenario. Waiting is not idleness. Waiting is readiness.