Build Your Own AI Software Factory with Claude Code

Summary

The video demonstrates how to build a lightweight, reusable AI software factory inside an existing project using Claude Code. The factory coordinates specialized agents to take a feature request through specification, implementation, review, and approval. Its goal is to automate much of feature development while retaining human oversight for risky or uncertain changes.

How the Factory Works

1. Specification: An agent turns a feature request into a written specification.
2. Implementation: A builder agent develops the feature, typically on a separate Git branch or worktree.
3. Review: Specialized agents perform security, UX, UI/design, and code reviews. If changes are needed, the work can loop back for revisions.
4. Approval: An approval agent decides whether the feature can be merged automatically or should be escalated to a person.
5. Human review and merge: The developer can inspect the status and supporting information in a dashboard, approve a task, and merge it.

The system is built from Claude Code skills, subagents, and Markdown files, rather than relying on a large external framework. Markdown files hold task and workflow metadata, while a dashboard provides visibility into progress and review status. The factory also checks prerequisites, such as requiring a clean working tree before starting.

Build and Feature-Development Walkthrough

The presenter creates the factory within an existing website repository. The setup includes an orchestrator skill, subagent definitions, a backlog, task metadata, and a dashboard.

The presenter then uses it to implement a website change: making the pages for an Obsidian Agent course free while keeping the videos paid. The task progresses through specification, implementation, and several reviews. The approval agent escalates the change for human review; after the presenter approves it, the feature is merged into the main codebase.

The presenter shows how the work was recorded in Git commits and notes that task metadata can be kept out of commits, though teams may choose to store or back it up elsewhere.

Parallel Development and Observations

The factory is extended to support multiple features at once using Git worktrees. Three example website tasks are run in parallel:

• Display estimated reading time on blog posts.
• Add a copy button to code blocks.
• Add a 404 page.

The presenter switches one orchestration session to Sonnet with lower effort to compare behavior, while noting that subagents can still determine overall speed.

The dashboard makes concurrent tasks and review progress easier to observe. The demo also reveals areas to improve: the approval process can be slow, safeguards may escalate too often, and unrelated or expected changes in the main branch can interfere with automatic merging. The presenter adjusts the factory’s rules to handle such changes more appropriately.

Broader Analysis and Future Extensions

The presenter frames agent-based software factories as an evolution of earlier ideas about standardized development environments and reusable tooling, followed by CI/CD pipelines. The key change, in this view, is automating relatively unstructured cognitive work—such as writing and reviewing code—between more deterministic stages.

Possible extensions include using GitHub Issues or Slack as task inputs, pulling bugs from monitoring systems such as Sentry, and incorporating infrastructure metrics such as CPU and memory. A factory could continue monitoring after deployment and potentially help respond to regressions or roll back changes.

A major trade-off is cost: using multiple agents creates extra context-passing overhead, although the presenter considers the additional review and visibility worthwhile for higher-quality results. The video’s central recommendation is to understand the basic agent-workflow concepts and build a small system tailored to one’s own project, rather than adopting a complicated framework without understanding how it works.

Guide and Tutorial Points

• Create the factory inside an existing project using Claude Code.
• Define an orchestrator skill and specialized subagents.
• Store workflow state and task metadata in Markdown files.
• Add a dashboard to monitor tasks, reviews, and human-approval needs.
• Require a clean working tree before starting tasks.
• Use Git branches or worktrees to isolate work and enable parallel feature development.
• Keep a human approval step for escalated changes.
• Tune review and merge rules based on practical failures.
• Consider how task metadata should be committed, ignored, or backed up.

Main speaker/source: The video’s presenter from the ZazenCodes channel. The presenter also identifies Anthropic as the sponsor.