I'm building a software factory to keep me connected to my code.

I am stepping away from writing code by hand and focusing on the architecture that allows me to directly influence that code by defining its rules, checks, heuristics, patterns and templates. I have not given up coding, because I believe the generated output is very important and understanding the behavior of the systems created by it is even more important. This is my attempt to responsibly think and act at a higher level without having to sacrifice the integrity, reliability and security of the systems I create. I am engineering my own software factory, rsb-workflow, which encapsulates these beliefs while taking advantage of the productivity gains. This workflow hands over code generation to a collection of agents without losing control of the code.

The factory is a feedback loop around coding agents. I write the rules and the measurements; agents write the code inside a default-deny sandbox, holding nothing but their own model sign-in; a custodian performs every effect on their behalf; CI and reviewers produce evidence; I merge on that evidence instead of reading every diff. When the evidence lies, I add a rule or a template, regenerate the same app from the same tickets, and measure whether it got better. Nothing is adopted on faith, including my own design choices.

The other half of the work is the record: every load-bearing decision is written down, argued, dated, and held to, and published as the pieces open. The code is what the record produced.

Rules are few and mostly prohibitions. Each carries a consequence: rules that guard the business or keep the agent inside its limits block the change; rules about coherence accrue debt in a ledger and get paid down on their own timeline. Every profile has a reference app that is regenerated to test the rules, never the other way round.

One folder per repo role. The factory never hosts an agent attempt; agents only ever work in projects/ and ref/. The loop runs on an always-on desktop under systemd and is driven from the issue tracker, so work can be started from anywhere.

• gauge — the engine: a stateless reconciler that derives each run from git and GitHub, supervised by systemd, Rust. Holds the driver that alone touches GitHub.
• agent-box — the sandbox an attempt runs in. Default-deny egress, no GitHub token, SSH key or Docker socket, read-only everything the agent doesn't own.
• agent-registry — rules, heuristics, checks, patterns and profiles, as TOML, versioned.
• rsb-skills — the spec, ticket and hand-back skills the agents and I both use.
• rsb.sh — the engineering record and, eventually, the published rules and data so you can build your own.

The remaining private pieces open as they stabilize; the rules and the data are the point of publishing, not the code.

• Lumen — a raw developer and photo catalog for the Linux desktop, built for my own photographs first. Local files, no subscriptions, no telemetry, no cloud. Rust. (libraw bindings and errors-rs are its first open crates.)
• Rollout — feature-flag management on Kubernetes. The reference application for the k8s profile.
• Daybook — double-entry ledger accounting for small creative businesses. The public example of a complete serverless system, with a live demo when it ships.
• Reference apps — one per stack profile, deliberately small, rebuilt from fixed tickets every time a rule changes.

Three families of software, each with its own profile: serverless TypeScript on Cloudflare, Rust and TypeScript for Kubernetes services, and Rust desktop applications.