For the complete documentation index, see llms.txt. Every page is also served as Markdown at its URL followed by .md.

standards
Software factoryExamples

Software factory

Start from the Factory bundle, give it one environment holding your repositories from the CLI, choose who writes the code, then make the pipeline your own.


Factory is a base model for a software factory: issues, projects and a timeline, four routines, and the skills those routines follow. It lands as a copy your workspace owns. You set up where it runs, then build on it. The objects stay solid, so the skills keep working while you add your own fields, routines and skills around them.

Some setup steps are manual, because only you can do them: install GitHub, store your keys, decide what may merge. This page lists each step in order. The setup decision you receive when Factory is added, Configurer Factory, opens a conversation that walks you through the same steps and does the workspace side for you.

The pipeline

RoutineRunsWhat it does
intakeOn a message in your Slack channelTurns a request into issues, or asks in its thread.
screeningEvery 15 minutesChecks each new issue against the code, then readies it or asks for a ruling.
buildEvery 30 minutesTurns an issue moved to In progress into a pull request.
landEvery 15 minutesJudges pull requests, fixes failing ones, then merges or asks a person to.

Each routine takes the next issue in its column, by priority and then by age. When a routine needs a person, its question arrives in Decisions. screening, build and land share one environment, Factory, which holds every repository: a routine started by the clock has no repository of its own to choose from.

Prerequisites

  • A workspace with Factory added. It is offered during onboarding; later, add it from Bundles in the profile menu. Adding its routines takes agents:manage.
  • The GitHub repositories the factory will work on, and the right to install a GitHub app on them.
  • The CLI, logged in: npm i -g @standards/cli, then standards login.
  • A key for the coding agent you want to use, unless the built-in agent writes the code.

Connect GitHub, and Slack for Intake

Open GitHub on the Connectors page and choose For the workspace. Other members choose Link my account on that installation. The routines read code and open pull requests with the GitHub account of the person who switches them on. There is no fallback account.

Slack is optional. Without it, you create issues in the app and intake stays off.

Create the Factory environment with every repository

standards environments create --name Factory --harness cursor \
  --repo acme/api --repo acme/web --image code \
  --visibility workspace --confirm-shared
  • --harness lists the coding agents the environment accepts: claude-code, codex or cursor, comma-separated. The built-in agent pilots any environment without being listed. standards environments harnesses lists the coding agents with their models.
  • If only the built-in agent will ever write the code, pass --harness standards and leave out --image: such an environment runs on the documents image, and it can never accept a coding agent later. To keep that option, list a coding agent now.
  • --visibility workspace lets every routine use the environment. --confirm-shared acknowledges that members share its machines.
  • Adding a repository later: --repo sets the whole list, so pass every repository, then build again.
standards environments update Factory --repo acme/api --repo acme/web --repo acme/docs

Give each repository its variables

A variable scoped to one repository reaches that repository's processes through its .env.local, and no other repository in the environment. From a repository's checkout, push every key its .env.example names, taking each value from its .env only:

for key in $(grep -oE '^[A-Z_][A-Z0-9_]*' .env.example); do
  value="$(env -i sh -c 'set -a; . ./.env; printenv "$1"' _ "$key")" || continue
  printf %s "$value" | standards secrets set "$key" --env Factory --repository acme/api
done

Each value is read in a clean shell, so a key missing from .env is skipped rather than taken from your own environment, and nothing is left exported in your terminal. Repeat it from each repository's checkout, with that repository's name. Values are read from stdin only and are never printed back. standards secrets list --env Factory lists the keys.

Use development or test values only. A Factory environment never holds a production secret: members can read its machines, and routines run code from issues.

Choose who writes the code

The built-in agent needs nothing more. For a coding agent you already pay for, store its key on the Factory environment, whose runs read it:

printf %s "$CURSOR_API_KEY" | standards secrets set CURSOR_API_KEY --env Factory

A workspace variable would also work, but one the workspace already holds keeps the environments it reaches: --environments Factory would replace its value without adding Factory to its reach.

PilotKey
claude-codeANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN
codexOPENAI_API_KEY
cursorCURSOR_API_KEY

Build it and check it

standards environments build Factory
standards environments get Factory     # its scripts and its last build log

Each run installs every repository the way its own files ask: packageManager, lockfile, engines. Add a setup script, in the environment's dialog in the app, only for what a repository's install cannot provide, such as a database or Docker. Never put a secret in it, since members can read the machine.

Tell each repository what the factory may do

The routines read a repository's rules from its target branch on every run. Add them to its AGENTS.md:

## Factory

- links: on
- merge: direct

## Verification

- `pnpm lint`
- `pnpm test`
  • ## Verification lists the commands that must pass before build opens a pull request. It runs exactly these.
  • merge: direct lets land merge once its judge says go. Without it, and without a merge queue, land sends a person a decision to merge each pull request.
  • links: on lets runs publish the running app on a private link, so you see the real screen before a merge. It is off by default.

Attach the routines, then switch them on

On the pages of screening, build and land, pick Factory as the environment and the pilot you chose, both above the instructions, then accept the confirmation. Pick the model under the instructions, and give land a different model from build, so a pull request is judged by a model other than the one that wrote it. intake stays on the built-in agent.

The Configurer Factory conversation handles the workspace side:

  • it groups your repositories into projects, with the context intake routes requests on;
  • it binds intake to your Slack channel;
  • it grants GitHub to the three routines.

Then switch each routine on from its page. A routine acts as whoever switches it on, so do it yourself, or have that person choose Link my account first.

Run a first issue

Post a request in the Slack channel, or create an issue in the app. screening picks it up within 15 minutes, checks it against the code and moves it to Ready, or asks you in Decisions. Move it to In progress: build opens a pull request, then land judges it.

A project's Auto launch box lets screening launch small, safe issues itself. It is off by default.

Make it yours

Factory is a copy your workspace owns. Build on it:

  • Add fields to issues and projects, for your own triage, your clients or your estimates.
  • Change a routine: its schedule, its instructions, its model.
  • Add routines next to the four, such as weekly release notes or a nightly dependency check.
  • Write your own skills for your conventions, and grant them to the routines that need them.

Keep the base intact. The skills read the objects, attributes and statuses Factory brings (issues, projects, timeline, and the statuses from Backlog to Done). Add next to them; do not rename or delete them. A skill that reads a status you removed stops working.

What happens to your changes:

  • Updating Factory brings the newer version in without touching what you changed: from Bundles, or with standards bundles update factory --dry-run, then --fingerprint <fingerprint> to apply.
  • Official skills update every night. A skill you edited stops updating automatically. The newer version is offered to you, and accepting it discards your edits. For a deep change, write your own skill instead.

Next steps

  • Environments: pilots, variables, setup scripts and what a routine run looks like.
  • CLI: agents: every environments and secrets command used above.
  • Bundles: how an added bundle is updated and uninstalled.
  • Decisions: where the routines' questions arrive.
  • Book a demo