Autonomous Software Factory
Portfolio case study · figures as of 2026-11-11

Software that ships while you sleep.

An autonomous software factory I designed and operate: 330 tested and audited open-source projects, 84% of the work delivered with no human fix, across four model providers.

330open-source projects delivered as pull requests
84%of 368 work items (projects, relaunches and modules) delivered with no human intervention
10large systems, from a SQL engine to a WebAssembly interpreter
  1. 23:25 human approved spec · prompt-injection-guard (Python)
  2. 23:25 budget reserved · expected $0.63, worst case $0.74
  3. 23:26 batch submitted at half price
  4. 23:45 code, tests and docs generated
  5. 00:02 gates: lint · format · types · tests · coverage · secrets · audit
  6. 00:03 4 correction rounds, file tools only, no shell
  7. 00:04 ✓ all gates passed
  8. 00:04 pull request #1 opened · 1 squashed commit
  9. 01:32 human reviewed and merged
  10. total API cost $0.75

Large systems

10 systems where one generation is not enough.

Each is a public repository with tests, CI and documentation. Most did not fit in a single model generation, so the factory grew an architect role that splits a system into modules with frozen interfaces and builds them in dependency order.

LSM key-value engine

Pure Go embedded log-structured merge-tree key-value engine with write-ahead log, memtable, SSTables, Bloom filters, and crash recovery.

Gou401-lsm-kv-engine

Linearizability checker

Deterministic linearizability checker for concurrent execution histories using Wing and Gong search with Lowe pruning, key partitioning, and minimal counterexample generation.

Gou402-linearizability-checker

WebAssembly interpreter

Zero-dependency WebAssembly MVP binary decoder, validator, and stack-based interpreter with explicit fuel metering and host imports.

Gou403-wasm-interpreter

CDCL SAT solver

Pure-Python CDCL SAT solver with two-watched-literals, 1-UIP learning, DRAT proofs, and assumptions.

Pythonu404-cdcl-sat-solver

JSON CRDT

Conflict-free replicated JSON document with maps, RGA sequences, PN-counters, state-vector sync, and binary encoding.

TypeScriptu405-crdt-json

Linear-time regex engine

Linear-time regular expression engine in TypeScript implementing a ReDoS-safe RE2 subset via Pike VM and lazy DFA.

TypeScriptu406-linear-regex

Spreadsheet formula engine

Zero-dependency spreadsheet formula engine in TypeScript with A1 reference parsing, incremental recalculation via dependency DAG, and cycle detection.

TypeScriptu407-formula-engine

Datalog engine

In-memory stratified Datalog engine in pure Python with semi-naive evaluation, DRed incremental view updates, aggregates, and derivation explanations.

Pythonu408-datalog-engine

Columnar SQL engine

Embeddable columnar SQL query engine in Go with vectorized batch execution, a rule-based optimizer, CSV tables and three-valued NULL logic.

Gou409-columnar-sql-engine

Git object store

Pure Python zero-dependency reader and writer for Git object stores, packed refs, and packfiles v2.

Pythonu410-git-objects

What happened, as it happened. All 10 were delivered: 1 in one generation, 6 after fixing gaps in the line itself, and the last 4 only after the architect re-planned them into 22 modules. 5 of the 10 were delivered by the line with no human fix; 4 conformance modules are held for review. Every hand fix is recorded as an intervention, 40 so far across all runs, and excluded from the autonomous rate. Model API cost of all 10: $34.

How it works

Eight steps, two of them human.

The models write and correct code; deterministic code decides what is accepted. Nothing reaches a repository without passing the gates a senior team would demand.

Approve

A human selects and approves each specification before anything is built.

Plan and budget

Every item is estimated against a monthly budget with a worst-case reservation.

Generate

Code, tests and documentation are generated in batch, overnight, at the lowest price tier.

Quality gates

Lint, format, types, tests and coverage, docs standard, secret scan and dependency audit.

Correct

A bounded correction loop fixes failing gates with file-level tools only, never a shell.

Independent audit

A separate read-only reviewer checks the result against its specification.

Publish

One clean, squashed commit per pull request; the factory never pushes to main.

Review

A human reviews and merges. CI re-runs the gates on Linux and Windows.

The twelve roles behind the steps models with narrow permissions, and deterministic code
  • Analyst (model): turns an idea into a specification with testable acceptance criteria.
  • Architect (model): splits a large system into modules with frozen interfaces.
  • Generator (model): writes the code, tests and documentation of one item in one batch request.
  • Fixer (model): repairs failing gates in bounded rounds, with file tools only.
  • Auditor (model): a read-only reviewer, separate from the author, that checks against the spec.
  • Docs writer (model): rewrites the documentation to match the code actually delivered.
  • Security engineer (model): Semgrep, OSV-Scanner and a STRIDE review where there is auth or user data.
  • Visual QA (model): screenshots web apps at two widths and checks contrast; evidence, never a gate.
  • Planner (deterministic): estimates each item and reserves its worst case against the budget.
  • Quality and security gates (deterministic): the checks every pull request must pass.
  • Publisher and release manager (deterministic): one pull request per item; tags only after a human merge.
  • Maintenance (deterministic): merges only patch dependency updates whose CI passed.

Anatomy of one utility

From specification to merged repository in two hours.

u010-prompt-injection-guard screens user input and retrieved content for prompt injection (OWASP LLM01) with explainable rules and Unicode de-obfuscation. Here is exactly what the factory did, from its own log.

  1. Specification approved. Problem, public API and testable acceptance criteria, such as the exact rules that must fire on "ignore all previous instructions".

  2. Budgeted and batched. Expected $0.63, worst case $0.74 reserved against the monthly cap.

  3. Generated. Library, tests, threat model and documentation in one batch request.

  4. Gates failed, then fixed. A long line, two format issues, an import-order bug and a false secret hit, corrected in four bounded rounds.

  5. Audited and published. An independent reviewer checked it against the spec; its two remarks were listed in the pull request for the human.

  6. Reviewed and merged by a human.

The receipt

generation$0.39
4 correction rounds$0.12
independent audit$0.17
documentation$0.08
total API cost, measured$0.75

Each line is rounded to the cent, so they add up to $0.76; the ledger total is $0.7528. 7 model calls, 485k input tokens (59% served from cache). Every utility in the catalog has the same ledger.

Measured on four providers

Same pipeline, same gates, different models.

The factory is model-agnostic, tested on four providers. Each assembly line runs the same specification format, gates and audit; only the models change. Line C is finished; line D is paused. Every figure comes from the factory's ledger, not from price sheets.

A · AnthropicB · GeminiC · DeepSeekD · Vertex AI (paused)
Delivered of the projects started100 of 100100 of 100100 of 10016 of 23
Delivered with no human fix100819612
Model API cost per project$0.94$0.27$0.12$2.18
Median time to pull request2.6 h0.3 h0.6 h2.4 h

Cost is the measured model API spend per delivered project: generation, corrections, audit and documentation. It is not a price quote for client work.

Methodology models, prices, definitions and notes

Models per role

  • Line A · Anthropic: generation and correction claude-sonnet-5-5; documentation claude-haiku-5-5.
  • Line B · Gemini (AI Studio): generation and correction gemini-3.8-flash at $0.75 / $3.75, promotional until 2026-12-31, generation in batch at half price; audit and documentation gemini-3.1-flash-lite at $0.25 / $1.50.
  • Line C · DeepSeek: generation deepseek-v4-pro (DeepSeek-V4-Pro-0813) at $1.32 / $3.96 before the 50 % off-peak discount; correction, audit and documentation deepseek-flash (DeepSeek-V4.1-Flash-1017) at $0.30 / $1.20.
  • Line D · Vertex AI: generation google/gemini-4-argon at $4.00 / $20.00, streamed, three requests in parallel; correction and audit google/gemini-3.8-flash; documentation google/gemini-3.1-flash-lite.

List prices in USD per 1M tokens, input / output, as of 2026-11-11.

Work items

A work item is one entry in the factory's ledger: each project a line started (323 in the table above), each relaunch of a project (9), each large system (10) and each of the 22 modules its architect planned, and each Unreal Engine toolset (4), 368 in all. 308 of them were delivered with no human fix (84%). The table counts only the projects each line started, so it shows 289 of 323.

More measured figures

  • Average lines per project (code / tests): A 662 / 610, B 479 / 366, C 446 / 413, D 1026 / 562.
  • Where the money goes: A 64 % generation, 17 % correction; B 12 % generation, 70 % correction; C 38 % generation, 31 % correction; D 31 % generation, 60 % correction.
  • 2,339 model calls in all, each logged with tokens and cost; 1,133 tests guard the factory itself.
  • Output languages: Python, TypeScript and Go; web applications are built with Vite and React under end-to-end, accessibility and Lighthouse gates.

Notes

Gemini generates almost for free, so its cost sits in correction. On 19 projects its low-cost correction model could not close defects of a few lines; they were finished by hand, and each hand fix is recorded as an intervention (this page said 84 by the pipeline alone before later fixes were recorded). Gemini's audit was also far cheaper and reported fewer findings, which reads as a less demanding reviewer rather than better code.

DeepSeek runs only in its off-peak price window, at half price, and is the cheapest line so far: it finished all 100 projects, 96 with no human fix. Line D puts code quality before cost: generation runs on a stronger model, which shows in larger projects, and most of its spend goes to correction. Line D is paused after 23 projects; its figures cover those, including early infrastructure problems fixed the same day (stalled connections and a per-project budget set too low).

All times use one definition: the median from submission to the model until the pull request opens, recomputed from the ledger. Earlier figures on this page were computed differently and are replaced.

Lines for OpenRouter and two self-hosted lines (a rented cloud GPU and a local laptop GPU) are built on the same pipeline and gates and have not run yet. Confidential client projects are routed only to providers that do not train on inputs and offer zero data retention, and every dependency is checked against a license profile.

What this shows

How I work.

Models do the work, code decides

I design systems where models write and correct, and deterministic code decides what ships: gates, budgets, permissions and an independent audit.

I measure everything

Cost, quality and autonomy are recorded per project, so every claim on this page comes from a ledger rather than an estimate.

Failures are reported too

Hand fixes, held modules and expensive lines are shown as clearly as the successes, and excluded from the rates they would flatter.

Let's talk.

I am looking for senior engineering roles and consulting work on AI systems: agents, LLM integrations, evaluation, and the guardrails that make them safe to ship.