---
type: "post"
id: "zazencodes-season-3-src-software-factory-claude-code-01c97c"
slug: "zazencodes-season-3-src-software-factory-claude-code-01c97c"
title: "zazencodes-season-3/src/software-factory-claude-code/README.md at main: zazencodes/zazencodes-season-3"
description: "A GitHub repository publishes a copyable Claude Code software factory that turns feature requests into specifications, isolated code changes, parallel reviews and either a merge or human escalation."
retrieval_nugget: "A GitHub repository publishes a copyable Claude Code software factory that turns feature requests into specifications, isolated code changes, parallel reviews and either a merge or human escalation. Its value is not an autonomy claim but a concrete operating pattern: explicit agent roles, file-based handoffs, bounded rework and a final approval gate."
published_at: "2026-11-18"
updated_at: "2026-11-18"
record_date: "2026-11-18"
date_kind: "published_at"
topics: ["claude","claude-code","github"]
entities: ["Claude Code","zazencodes"]
related_patterns: ["ai-native-orgs-move-to-review-and-orchestration"]
novelty_label: "new_angle"
what_changed: "The account frames agent-driven code production as a repeatable factory process, tracing the concept to the late 1960s."
prior_refs: ["https://newruntime.com/posts/orchestrating-a-one-person-software-factory-run-many-5705c0/","https://newruntime.com/posts/gumloop-says-its-internal-software-factory-merged-571-68e712/"]
source_url: "https://github.com/zazencodes/zazencodes-season-3/blob/main/src/software-factory-claude-code/README.md"
source_urls: ["https://github.com/zazencodes/zazencodes-season-3/blob/main/src/software-factory-claude-code/README.md"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:zazencodes-season-3-src-software-factory-claude-code-01c97c"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/zazencodes-season-3-src-software-factory-claude-code-01c97c/","markdown":"https://newruntime.com/posts/zazencodes-season-3-src-software-factory-claude-code-01c97c.md","json":"https://newruntime.com/posts/zazencodes-season-3-src-software-factory-claude-code-01c97c.json"}
markdown_url: "https://newruntime.com/posts/zazencodes-season-3-src-software-factory-claude-code-01c97c.md"
---

# zazencodes-season-3/src/software-factory-claude-code/README.md at main: zazencodes/zazencodes-season-3

## Retrieval answer

A GitHub repository publishes a copyable Claude Code software factory that turns feature requests into specifications, isolated code changes, parallel reviews and either a merge or human escalation. Its value is not an autonomy claim but a concrete operating pattern: explicit agent roles, file-based handoffs, bounded rework and a final approval gate.

## Summary
A GitHub repository publishes a copyable Claude Code software factory that turns feature requests into specifications, isolated code changes, parallel reviews and either a merge or human escalation. Its value is not an autonomy claim but a concrete operating pattern: explicit agent roles, file-based handoffs, bounded rework and a final approval gate.

## What happened
The README for zazencodes’ “Software Factory for Claude Code” describes a small template built from one Claude Code skill, seven subagents and plain Markdown files. A user starts a job with `/factory <feature>`. The Claude Code session running the command acts as orchestrator; it spawns agents and is the only writer of the job’s `job.json`. Agents take context from files rather than the conversation and each writes to its own file.

The workflow begins with a spec writer, followed by a builder that implements the feature on a separate `factory/<job-id>` branch. Each job gets its own Git worktree alongside the repository. Four reviewers—security, UX, UI and code—run in parallel. Each review must produce a file whose verdict is either `PASS` or `CHANGES`; the round is complete only when all four files exist. If any reviewer requests changes, the same builder resumes, for at most two rounds.

An approver then writes a decision that starts with `APPROVE` or `ESCALATE`. An approved job can merge to `main`; an escalated one waits for a human. The README also documents commands for processing the first unchecked backlog item, approving a job that needs human attention, and sending one back to the builder with feedback. Multiple Claude Code sessions can run `/factory` independently to work on features in parallel.

The template is intended to be copied into a repository: copy `.claude/` and `factory/`, remove the sample jobs and checked backlog items, and add `/factory/jobs/` to `.gitignore`. The author says the project’s `AGENTS.md` or `CLAUDE.md` should explain how to set up a fresh checkout, start the development server and run tests, build and lint. For projects with pages, the builder and UX/UI reviewers can use the agent-browser CLI to inspect the running app.

Two example jobs come from the creator’s Vue and Firebase site. One passed all four reviews in its first round, but the approver escalated it because it edited a prerender script regarded as a deploy change; a human reviewed the decision and approved it. The other passed review and was merged by the approver. The README says the factory has evolved beyond the original build prompt: jobs now use separate worktrees and `job.json` files, allowing concurrent work rather than a single shared board.

## What the archive adds
New Runtime’s earlier coverage has treated software factories as both a product architecture and an operating model. [SuperPlane 1.0](https://newruntime.com/posts/superplane-1-0-launches-as-an-open-source-14c409/) (2026-11-02) framed one as a shared system for tickets, coding agents, verification and review; [Oskar Groth’s one-person factory](https://newruntime.com/posts/orchestrating-a-one-person-software-factory-run-many-5705c0/) (2026-11-11) described orchestration across discrete outcomes. This is a new implementation example, not a restatement: the README makes the reviewer loop and escalation mechanics especially explicit.

## Trend signal
This supports [AI-native organizations moving toward review and orchestration](https://newruntime.com/patterns/ai-native-orgs-move-to-review-and-orchestration/). The factory divides work into specification, implementation, independent review and ownership of the final decision, rather than treating faster code generation as the whole measure of progress. The examples also expose a practical boundary: passing technical review does not automatically authorize a change that an approver considers operationally risky.

## Why now
The README says the factory has grown since its original build prompt: each job now has its own worktree and job file, which makes parallel jobs possible. That evolution matters because concurrency changes the coordination problem; a single shared board or conversation becomes a weaker place to track independent work.

## Why it matters
For a team adopting coding agents, this template offers a way to make responsibilities inspectable. Separate files mean reviewers can see what an agent was asked to produce and what each check concluded; isolated worktrees reduce collision between simultaneous jobs. Requiring all four reviews before a round closes also makes missing checks visible instead of silently treating partial review as approval.

The human gate is equally important. The example involving a prerender script shows that a change can satisfy review checks and still deserve escalation because of its deployment implications. Teams can adapt the pattern by defining which paths, operations or policy decisions always require a person, and by making the approver’s decision a recorded artifact. The repository is a template rather than evidence that these safeguards will work unchanged across stacks, but its boundaries are concrete enough to test in a small pilot.

## Limits and uncertainty
The README gives two example jobs, not a measured evaluation of the factory across repositories or a comparison with ordinary Claude Code use. It reports no completion times, failure rates, reviewer precision, cost or production reliability. The examples are from the creator’s own Vue and Firebase site, so they do not establish how much adaptation other stacks require. Nor does the description establish that separate agent files prevent conflicting changes or that the stated review roles catch a particular class of defect; teams would need to validate those checks against their own code and risk profile.

## Skill to build now
Pilot the workflow on one low-risk feature. Write down the project setup and test commands in `AGENTS.md` or `CLAUDE.md`, then define what each reviewer must inspect and which changes trigger escalation. Preserve the separate job worktree and require every reviewer to return an explicit pass or change request. After the pilot, inspect whether the verdicts caught useful issues and whether the human approval boundary was clear before expanding to parallel jobs.

## Reader takeaway
The reusable idea is a controlled production loop, not “seven agents” by itself: isolate each job, make handoffs visible, require complete reviews, cap rework and reserve a human decision for risky changes. Start with a small feature and tune the checks to the repository before trusting the factory with broader work.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Claude](https://newruntime.com/topics/claude.md): Explore the claude topic hub.
- topic hub: [Claude Code](https://newruntime.com/topics/claude-code.md): Explore the claude-code topic hub.
- topic hub: [Github](https://newruntime.com/topics/github.md): Explore the github topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
