# factory: Build a Software Factory for Claude Code and Codex

This repository profile is provided by osrepos.com, an open source repository discovery platform.

Source: osrepos.com
Repository profile: https://osrepos.com/repo/addyosmani-factory
Generated for open source discovery and AI-assisted research.

factory installs a repeatable software-delivery workflow into an existing GitHub project, built around stock Claude Code with a thin Codex adapter. It turns issues into reviewed draft pull requests while keeping scope, verification and merge decisions under human control.

GitHub: https://github.com/addyosmani/factory
OSRepos URL: https://osrepos.com/repo/addyosmani-factory

## Summary

factory installs a repeatable software-delivery workflow into an existing GitHub project, built around stock Claude Code with a thin Codex adapter. It turns issues into reviewed draft pull requests while keeping scope, verification and merge decisions under human control.

## Topics

- claude-code
- coding-agent
- shell
- automation
- agent-orchestration
- software-factory
- issue-triage

## Repository Information

Last analyzed by OSRepos: Thu Nov 19 2026 05:20:28 GMT+0000 (Western European Standard Time)
Detail views: 0
GitHub clicks: 0

## Safety Notice

OSRepos shares public repositories for knowledge and discovery only. Review source code, dependencies, licenses, and security implications before running or installing anything.

## Content

## Overview

factory is an installer for a repeatable software-delivery loop built around stock Claude Code, with a thin Codex adapter using the same policy and queue. It adds rules and procedures to an existing GitHub project so scheduled or manually started agent sessions can triage issues, implement bounded work, run checks and open draft pull requests without a separate orchestrator or queue service.

It is aimed at teams that want to make agent work restartable and reviewable, rather than relying on conversation history or hand-steering each session. GitHub Issues and pull requests hold the durable work state; people define what agents may do and retain responsibility for product decisions and every merge.

## Key Features

- Installs a human-owned charter for scope, risk, protected paths and stop conditions.
- Uses GitHub issues and `factory:*` labels as the work queue, with structured handoffs between stages.
- Provides triage, specification, implementation, verification and monitoring workflows.
- Runs deterministic quality gates and fails closed when required checks are missing.
- Uses a separate verifier to inspect changes and test whether new tests fail without the implementation.
- Claims work with deterministic branches to prevent competing runs from owning the same issue.
- Provides a `/factory` control room for the review queue and a configurable cap on pending reviews.
- Supports Claude Code routines, with Codex adapters for running shared stages interactively.

## Use Cases

- A small engineering team wants agents to pick up explicitly permitted, low-risk GitHub issues and prepare draft pull requests for review.
- A project maintainer needs a consistent triage path that routes unclear issues to a human instead of encouraging speculative implementation.
- A team using Claude Code wants scheduled issue processing and pull-request verification without operating a custom orchestration service.
- A Codex user wants to apply the same repository policy and workflows interactively, while keeping the GitHub queue and evidence shared.

## Our Take

factory is a clearly bounded reference implementation for teams that want repeatable agent work with human-controlled scope and merges, but its quiet recent activity and single-contributor base warrant caution before relying on it as maintained infrastructure.

**Good fit if:**
- You use GitHub with Claude Code, or want to run the shared workflows interactively with Codex.
- You can define a project charter, provide real test and build commands, and have people review every proposed change.
- You want repository-owned queue state and verification procedures rather than a separate queue service.

**Look elsewhere if:**
- You need unattended Codex schedules provisioned by the repository, or immediate issue triage without installing the optional Action.
- You expect agents to merge changes or want to remove human approval from the delivery process.
- You need a project with demonstrated recent maintenance from a broader contributor base.

## Project Health

| Signal | Value |
|---|---|
| Status | **Quiet**: no commits in the last 90 days and no release in a year |
| Last commit | 2026-08-21 (3 months ago) |
| Commits, last 90 days | 0 |
| Releases, last 12 months | 0 |
| Contributors | 1 |
| Issues closed, last 90 days | 0 |
| Pull requests merged, last 90 days | 0 |
| Project age | 3 months |

Checked on 2026-11-19 with the GitHub API.

## Project Facts

- Language: Shell
- License: MIT
- Stars: 369
- Forks: 26
- Topics: agentic-engineering, claude-code, codex, software-factory
- Archived: no

## What You Need

Detected in the repository:

- Shell (main language on GitHub)
- A test suite and automated checks on GitHub Actions

## Getting Started

Clone the installer and run it against the project you want to automate:

```bash
git clone https://github.com/addyosmani/factory.git
/path/to/factory/install.sh --dry-run /path/to/your/repo
/path/to/factory/install.sh /path/to/your/repo
```

Read the repository [README](https://github.com/addyosmani/factory) and `GETTING_STARTED.md` for setup and validation details.

## License in Plain Words

**MIT** (permissive).

- Commercial use: yes
- Modify and redistribute: yes
- You must keep: the copyright and license notice
- Share your changes: no

A summary, not legal advice: the LICENSE file is what applies.

## Alternatives

- [aidevops](https://osrepos.com/repo/marcusquinn-aidevops): aidevops is a broader AI DevOps framework for intent-to-verified outcomes, while factory installs an issue-to-reviewed-draft-PR workflow in an existing GitHub project.

| Project | Language | License | Stars | Status |
|---|---|---|---|---|
| **factory** | Shell | MIT | 369 | Quiet |
| [aidevops](https://osrepos.com/repo/marcusquinn-aidevops) | Shell | MIT | 439 | Active |

## Considerations

The repository reports no commits in the last 90 days and no release in over a year. Most of the work comes from one contributor, so adopters should assess maintenance capacity and validate the installer and workflows against their own project before enabling writes.

Claude routines do not provide a native trigger for newly created issues in this setup. The default triage process polls on a schedule, so issues can wait until the next run; an optional GitHub Action can call the routine API for faster triage. Codex schedules are not provisioned automatically. The project also notes that cloud environment settings are account-level configuration, and that hooks blocking common merge paths are guardrails, not a substitute for GitHub branch protection.