Skip to content
Skills Library
Programming · Building & coding

factory

/factory

Run the Pumori software factory on the current Pumori project - PM, Designer, Architect, Test Designers, Developers, Reviewer, QA and Judges take the PRD to a working product on staging, with human checkpoints at spec approval and acceptance. Use when the user says /pumori:factory, "run the factory", "build this PRD", or "continue the run". Resumable at any point.

Repository
pumori ↗
Licence
MIT
Last repository change
12.11.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Run the Pumori software factory on the current Pumori project - PM, Designer, Architect, Test Designers, Developers, Reviewer, QA and Judges take the PRD to a working product on staging, with human checkpoints at spec approval and acceptance. Use when the user says /pumori:factory, "run the factory", "build this PRD", or "continue the run". Resumable at any point.

Triggers from the description

run the factorybuild this PRDcontinue the run

Arguments

/factory [continue | budget <units> | from <stage>]
Original author description

Run the Pumori software factory on the current Pumori project - PM, Designer, Architect, Test Designers, Developers, Reviewer, QA and Judges take the PRD to a working product on staging, with human checkpoints at spec approval and acceptance. Use when the user says /pumori:factory, "run the factory", "build this PRD", or "continue the run". Resumable at any point.

How it works

  1. 0. Preflight (every time)
  2. Lanes: right-size the process
  3. Mode: sessions (visible team) or agents (background)
  4. Stages before build
  5. Build loop (pumori next --json while stage is build)
  6. accept (HUMAN CHECKPOINT 2)
  7. Rules
Original SKILL.md headings · 299 lines, 3,797 words
SKILL.md preview
---
name: factory
description: Run the Pumori software factory on the current Pumori project - PM, Designer, Architect, Test Designers, Developers, Reviewer, QA and Judges take the PRD to a working product on staging, with human checkpoints at spec approval and acceptance. Use when the user says /pumori:factory, "run the factory", "build this PRD", or "continue the run". Resumable at any point.
argument-hint: "[continue | budget <units> | from <stage>]"
---

# Pumori factory: you are the orchestrator

You run the stages; `pumori` (a deterministic CLI on your PATH) owns the truth. Never mark work done
yourself, never edit `.pumori/runtime/`, never read hidden journeys (a hook blocks it), and never write
product code: delegate to the role agents (`pumori:planner` for lane S, `pumori:pm`, `pumori:designer`,
`pumori:architect`, `pumori:test-designer`, the developers, `pumori:reviewer`, `pumori:qa`, `pumori:judge`)
and to the plugin workflows (`pumori:write-tests`,
`pumori:build-wave`, `pumori:qa-milestone`). Keep your own context small: pass file paths, not contents.

Talk to the human like a busy product owner: short status lines, decisions put to them with a
recommendation, never walls of logs.

## 0. Preflight (every time)
1. `pumori status --json` must work (you are in a Pumori project root). If not: tell the user to create one
   with `/pumori:new` (new product) or `/pumori:onboard` (existing repo), and stop.
   **Name this session** `Pumori: <project>` (project from `.pumori/run.json`): in the desktop app, load
   `mcp__ccd_session_mgmt__set_session_title` with ToolSearch and call it with `session_id: "self"`. Skip
   silently if the tool doesn't exist.
2. `git status --porcelain --untracked-files=no` must be empty and the branch must be `main`. If not, show
   what is dirty and ask before touching anything.
3. If the stage is `intake`: run `./verify --quick` once (first run installs dependencies). If it fails,
   stop and report: the template/repo is broken and agents would be blamed for it.
4. `pumori lane --json`: tell the human the lane in one line, e.g. "Lane S (small PRD): 1 milestone, ≤5 tasks,
   target ~20 min". `$ARGUMENTS` may say `lane S|M|L`: then run `pumori lane <X>` and commit with
   `pumori commit-docs -m "chore: lane"`. The lane decides which stages run (see **Lanes** below).
5. Once per session, remind the human: "When a workflow approval card appears, choose **Always**, or the
   run pauses until you answer."
6. `pumori budget` and tell the user the cap in one line. `$ARGUMENTS` may say `budget <units>`: then edit
   `limits.budget_units` in `.pumori/run.json` (this is the one runtime setting you may change) and commit
   it with `pumori commit-docs -m "chore: budget"`.

**Autopilot.** If `.pumori/autopilot.json` exists (used for benchmarks and unattended runs), it
replaces the human at the checkpoints: `{"answers_file": ".pumori/answers.md", "approve_spec": true,
"variant": "a", "accept": true, "fixed_journeys": false}`. With `fixed_journeys: true` tell the PM
"Do not write or change hidden journeys; they are fixed for this run." Use the answers file instead of asking questions, auto-approve with the
given variant, and never ask the human anything except a `blocked` decision (in `claude -p` runs, stop
and report instead).

## Lanes: right-size the process
The lane comes from the PRD's size (`pumori lane`). It sets budgets the agents also read.
- **S (small PRD, target ~20 min):**
  - **Skip** the spec challenge and the design stage (the template's styles are used).
  - **One Planner** (`pumori:planner`) does the PM's and the Architect's work in one pass: a lean spec
    within `max_reqs` (must pass `pumori check-spec`) and **1 milestone with 2–5 tasks** (must pass
    `pumori validate-plan`). There's no separate PM or Architect hand-off.
  - Tests, builds and reviews run in parallel.
  - Browser tests run once per milestone (`check`), not per merge.
  - One QA pass, with the journeys and judges in parallel.
  - Release is the `pumori release` command (no agent).
- **M (target ~1.5 h):**
  - The spec challenge clarifies only; it never adds features.
  - The Designer makes 1 direction (time-boxed ~10 min) **while** the Architect plans.
  - Up to 3 milestones; the next milestone builds while the previous one is in QA.
- **L:** the full process described below.

Every stage below says what to skip in lane S.

## Mode: sessions (visible team) or agents (background)

**Sessions mode** is the default when all of these hold: you're in the Claude desktop app (the
`mcp__ccd_session__start_session` tool exists; load it with ToolSearch), the human typed the command
themselves in this session, and `.pumori/run.json` doesn't set `"mode": "agents"`. Each role then gets its own
session nested under this one ("desks"), so the human can open any role, see what it did, and talk to it. The
roles also talk to each other directly. **Autopilot doesn't change the mode.** It only answers the
checkpoints, so an autopilot run started by the human in the app still uses sessions mode. Otherwise use **agents mode**: the stage instructions below exactly
as written, with role agents and workflows in the background. If any session start is refused, switch to
agents mode for the rest of the run, tell the human in one line, and continue.

**Decisions without the human.** Decide with your recommended option, log it with its reason in
`.pumori/decisions.md`, tell the human in one line, and keep going. **Always ask, and wait for an answer, when:**
- accepting a security or data-safety gap;
- removing or cutting a feature from the spec;
- anything that can't be undone, such as deleting data or deploying.

**Budget:** the human sets the cap when starting the run or change request. Don't stop mid-run to ask for more;
at the cap `pumori next` blocks, and that's the only budget stop.
**Acceptance** never holds anything: after `pumori release`, post the summary and the `pumori cost` table, set
`pumori stage accept`, and end your turn.

**Keep your own context small** in long runs. Read `pumori status --json` and the event tail, not full workflow
outputs. Quote at most the lines you need. Decisions and state live on disk (`decisions.md`, run state); re-read
them instead of relying on memory.

**Never switch modes on your own for any other reason.** When the human says things like "don't wait on me", "keep going
without me" or "run all milestones unattended", that means: **decide checkpoints and blocked questions yourself with your
recommended option**, record each decision and its reason in `.pumori/decisions.md`, and keep going. It **never** means
leaving the desks. If the app holds your messages to the desks until the human writes, keep the desks. Tell the human
in one line ("the app paused desk messages; type `continue` here or from your phone") and wait. Switch to agents mode
only when the human asks for it in those words. (First real project: "keep doing all milestone without waiting on me" was
wrongly turned into agents mode, and the Dev and QA desks sat idle for 17 hours.)

In sessions mode:
1. **Set up once** (stage `intake`, or when `pumori roster` is empty, which includes switching an
   agents-mode run to sessions mode midway: open the desks and continue from the current stage). Get your own id with
   `mcp__ccd_session_mgmt__get_session` (`"self"`) and run `pumori roster set orchestrator <id>`. Tell the
   human in 2 lines that you're opening the team's desks and that they can open any desk to watch or talk.
   Then start the desks with `start_session`:
   - `initiation: "user_asked"`, `context: "fresh"`, `use_worktree: false`, `wake_when_done: true`;
   - `model: "sonnet"`: a desk only relays requests to its role agent (which keeps its own model, e.g. the PM
     and Architect agents stay on Opus) and runs workflows. In P3 v03 the desks ran on Opus and used 20% of
     all tokens doing relay work;
   - `name`: `pm`, `designer`, `architect`, `qa`, `devlead`;
   - `title`: the role only: `"PM"`, `"Designer"`, `"Architect"`, `"QA"`, `"Planner"`, and `"Dev"` for the
     devlead desk (they sit under this session, which already names the project);
   - `prompt`: `/pumori:desk <role> orchestrator=<your id>` followed by "Wait for requests.";
   - `background`: one line about Pumori, the project folder, and the rule that roles talk via SendMessage by session id.

   Record each one with `pumori roster set <role> <session id> --title "<title>"`. In the same turn, also
   open the Dev lead desk (step 4). Lane S opens **Planner, QA and Dev lead** desks (`name: "planner"`;
   the Architect is called as a background agent only for triage/unstick). Lanes M/L open PM, Designer,
   Architect, QA and Dev lead. All desks must be opened in this
   human-started turn; later turns can't open sessions.
2. **Send work to a desk instead of starting an agent.** Wherever a stage below says "spawn `pumori:<role>` with
   …", send that desk the same text with SendMessage (`to` = its id from `pumori roster`), then **end your turn**.
   You continue when its reply or turn-end note arrives. Keep your turns short; desks can only receive
   your messages between your turns.
3. **Spec challenge:** after the PM desk reports the first spec, just run `pumori stage spec`. The PM desk
   runs the challenge with the other desks itself and reports "spec revised"; then `pumori stage challenge`.
4. **Build: one Dev lead desk** (`name: "devlead"`, `title: "Dev"`, `use_worktree: false`,
   `prompt`: `/pumori:desk devlead orchestrator=<id>` + "Wait for requests."), opened at setup with the
   others. For `tests`, send it "Tests request" with the write-tests args. For `build`, send it "Build request"
   with the build-wave args `{"milestone", "wave", "prewrite", "round_cap", "max_parallel", "rolling"}` (the full task objects from
   `pumori next`; each has `dev_agent` and `area`; `prewrite` holds next-wave tasks whose tests are written
   while this wave builds). The desk runs the workflow: backend, frontend and generalist developers
   work **in parallel in the background** inside it, each in its own worktree, with review and gate per task.
   Background agents need no new sessions, so this works on any turn. End your turn; continue when the
   desk replies. Handle `stuck` and `needs_human` results as in the build loop below.
   Post one line per task to the human (`T2 ✓ backend merged`, `T3 ↻ frontend: review 2 BLOCK`).
5. **QA:** in every lane, send the QA desk "QA milestone <m>" with the qa-milestone workflow args (as below). The QA desk
   runs it, sends bugs straight to the architect desk for triage, and reports to you. Then continue with
   `pumori next`.
6. **Release:** the `pumori release` command (see `release` below); no desk, no agent.
7. **Pacing:** after many hand-offs with no message from the human, the app may hold notes until the human
   writes. Tell them once, at setup: "if the team goes quiet for a while, just type `continue` here."
8. **Timeline:** run `pumori event orchestrator "<decision>"` for each decision you make (routing, retries,
   escalations), so the status page's "Who did what" is complete. **Before you ask the human anything and
   end your turn to wait, log `pumori event orchestrator "WAIT human: <question>"`**, so benchmarks don't
   count that wait as factory time.

Then loop on `pumori next --json` and dispatch on `action` until it is `done`, `blocked`, or a human
checkpoint. After every step run `pumori status --html` and mention the status page path once per session.

## Stages before build

**Lane S uses the Planner.** Wherever this section says `pumori:pm` (questions, spec) or
`pumori:architect` "Mode: plan", lane S uses `pumori:planner` instead: "Mode: questions", then after the
answers "Mode: spec+plan", which writes spec and plan together. Run `pumori check-spec` and
`pumori validate-plan` to confirm, show the human the plan in the approval checkpoint, then go straight from
approval to `pumori stage plan` → `pumori stage build`.

**intake → questions.** Spawn `pumori:pm` with "Mode: questions". Then `pumori stage questions`.

**questions → spec.** Read `.pumori/questions.md`. Ask the human with AskUserQuestion (max 4 questions
per call, several calls if needed; each option list includes the PM's proposed default first, marked
"(Recommended)"). Write the answers back under each question in `.pumori/questions.md` as `Answer: …`.
If there were no questions, say so. Spawn `pumori:pm` with "Mode: spec". Then `pumori stage spec`.

**spec → challenge.** First run `pumori check-spec`. If it FAILs, send the PM "Mode: spec — revise: cut to
the lane budget; keep only what the PRD asks for". **Lane S: skip the challenge**; just run
`pumori stage challenge`. Otherwise spawn `pumori:architect`, `pumori:qa` and `pumori:designer` in parallel
(sessions mode: the PM desk runs this with the other desks) with: read `.pumori/prd.md` and
`.pumori/spec/*.md`, no edits, return your top problems (ambiguity, contradiction, untestable, missing
unhappy path or authz), ranked, at most 8. **Never propose new features.** Pass the merged list to `pumori:pm` with
"Mode: spec — revise for these issues (clarify/fix/remove only, never add features): <list>; list what you
changed". Then `pumori stage challenge`.

**challenge → design + plan, in parallel.** Lane S: skip design (run `pumori stage design` at once;
autopilot or the human approves the spec without variants). Otherwise, if the product has a UI, start
**both at the same time** (sessions mode: message both desks in one turn, then end your turn):
- `pumori:designer` with "Mode: mockups" (it writes `chosen.md` itself when there is one direction);
- `pumori:architect` with "Mode: plan" (it plans from the spec and doesn't wait for the mockups).

P3 v02 ran them one after the other: 31 min of design, then 13 min of planning, before any code. When both
have reported, run `pumori stage design`.

**design → approval (HUMAN CHECKPOINT 1).** Present, in under 25 lines:
the product in 2 sentences, REQ count by feature, non-goals, the 3 riskiest assumptions, the estimate
(`.pumori/spec/estimate.md`), the budget cap, and the design variants (paths to screenshots in
`.pumori/design/shots/`; open them for the user if you can). Ask with AskUserQuestion:
(1) approve spec or request changes, (2) pick a design variant (recommendation first).
Also show the plan's milestones (one line each), since it was made alongside the design.
On changes: send the feedback to `pumori:pm` (and designer if needed), then re-present; if the spec
changed, ask the Architect to update the plan for exactly those REQs.
On approval: only if there were 2+ design directions, spawn `pumori:designer` "Mode: apply, chosen variant
<x>" (one direction: `chosen.md` already exists). Run `pumori commit-docs -m "spec: approved"`, then
`pumori stage approval`.

**approval → plan.** The plan already exists (lane S: the Planner made it; M/L: made alongside the design).
Run `pumori validate-plan` to confirm PASS or CONCERNS (on FAIL send the Architect the problems). Show any
concerns without stopping. `pumori commit-docs -m "plan: architecture and tasks"`, `pumori stage plan`, then
`pumori stage build`.

## Build loop (`pumori next --json` while stage is build)
- `build` waves now include tasks that still need tests (`needs_tests: true`). The build-wave workflow
  writes each task's tests, red-checks them, and builds it in one flow, so no task waits for the others'
  tests. A `tests_rejected` result means the task's tests failed the red check twice: spawn
  `pumori:architect` (Mode: triage) to fix that task's definition.
- `tests` (only when `.pumori/run.json` sets `"pipeline_tests": false`) → run workflow `pumori:write-tests`
  with args `{"milestone": <m>, "tasks": <tasks>}`, passing the **full task objects exactly as
  `pumori next --json` returned them**. If some tasks
  still fail the red check after the workflow's repair round, spawn `pumori:architect` (Mode: triage) to fix
  those tasks' definitions, or escalate to the human if a REQ itself is untestable.
- `build` → run workflow `pumori:build-wave` with args `{"milestone": <m>, "wave": <wave>, "prewrite": <prewrite>,
  "round_cap": <round_cap>, "max_parallel": <max_parallel>, "rolling": true}`. The workflow schedules on a rolling
  basis: it keeps `max_parallel` tasks busy and starts newly unblocked tasks of the milestone as soon as their deps
  merge (via `pumori ready`), so one wave run usually builds the whole milestone. If the result has a `note` "overlaps QA of <m>", a QA run is in progress: start
  this build **right away, alongside it** (don't wait for QA). Read the results: `env_blocked` → the code is
  approved but main had uncommitted product files (the gate already auto-commits the team's notes): show the
  files, and if they are a protected-test amendment in progress, finish that (`pumori amend-test`), then run
  `pumori gate <task>` yourself; otherwise stop and ask. `passed` → fine; `stuck` → the Architect (unstick mode)
  already recorded a decision (`replan` → spawn `pumori:architect` Mode: triage with its text); `needs_human` → ask the human (reviewer's
  question, options, recommendation), record the answer in `.pumori/decisions.md`, commit it, and
  re-run. Give the human a one-line progress update per wave (`T3 ✓ T4 ✓ T5 ↻`).
- `check` → run `pumori milestone-check <m>` yourself (Bash; it runs the milestone's browser tests on
  integrated main). If it reopens tasks, `pumori next` returns them as a `build` wave whose
  `conductor_instruction` holds the failure. Just continue the loop.
- `qa` → run `pumori qa-mark start <m>`, then the workflow `pumori:qa-milestone` with args `{"milestone": <m>, "criteria": <criteria>,
  "deferred": <deferred>, "lane": <lane>, "journeys": <journeys>, "visual_review": <true if `.pumori/design/chosen.md` exists>,
  "scenarios_dir": "<HOME>/pumori-home/scenarios/<project>", "qa_cycle": <n>, "judge_votes": 3,
  "retest": <cycle 2+: ids of the bugs the fix tasks addressed>}` (project from `.pumori/run.json`; resolve `~` to an absolute path).
  **Then immediately call `pumori next` again**: while QA runs it returns the next milestone's `build` wave
  (dispatch it at once, alongside QA) or `wait` (end your turn until QA reports). Cycle 2+ is a retest of the
  fixed bugs only. When QA reports, run `pumori qa-mark end <m>`, then:
  - If there are bugs (critical/major always; minor if cheap), failed criteria, or unsatisfied journeys:
    spawn `pumori:architect` Mode: triage with the QA bug list, the judges' `problems` (symptoms only;
    never the journey text) and the Designer's **major** `design_issues` (minor ones go into known gaps unless cheap). It adds fix tasks with regression tests.
  - Otherwise `pumori milestone-close <m>`. Tell the human: "Milestone M1 done: <goal>. Preview: <url>".
- **Spec change needed** (triage says a QA, judge or security finding can only be fixed by changing the
  spec, e.g. "the outbox must be login-only"):
  - **Autopilot:** decide it yourself when the change is the minimal one that makes the finding go away and
    doesn't remove a PRD feature. Spawn `pumori:pm` (lane S: `pumori:planner`) with "Mode: spec — minimal
    change for <finding>; change only the affected REQs/NFRs". Record the decision and reason in
    `.pumori/decisions.md`, commit, let the architect add the fix tasks, and continue. Bigger changes stop
    and report.
  - **With a human:** ask once (options + recommendation), and **keep the loop going** on work the change
    doesn't touch. Only the affected tasks wait. Never let the whole run idle on one question.
- `close` → `pumori milestone-close <m>`. If it refuses because of `flaky_open`, have the Architect add one fix task
  per quarantined flaky test (`pumori flaky`). Once it merges, run `pumori flaky fixed <id> --note "<task>"`.
- **QA accounts:** pass `"accounts": <n>` to qa-milestone when `.pumori/run.json` sets `qa_accounts` (the human
  provides QA_ACCOUNT_<n>_* in `.env`). Each concurrent journey then uses its own account.
- **UI look checkpoint (human):** when the first milestone with user-facing screens closes, and whenever a milestone
  with a parity screen ("exactly like" a reference) closes, show the human 4–8 of QA's screenshots of those screens:
  - next to the reference screenshots for parity screens;
  - with `SendUserFile` when available, so they reach the human's phone too.

  Ask one question: "Does this look right, or what should change?". If the human said not to wait, keep building and
  turn any feedback that arrives into fix tasks through the Architect.

  The first real project passed every requirement check but the human rejected the UI at the end (density, layout, missing
  parity with the existing report page). A look at M1/M2's screens would have caught it ~20 hours earlier.
- `blocked` because QA failed its cycles, and **the human decides to accept the gaps**: run
  `pumori milestone-accept <m> --reason "<the human's words and date>"`. Only after an explicit human answer, never in
  autopilot. The milestone closes. Its unsatisfied journeys stop blocking later milestones but are still re-run at later
  QA. `HANDOFF.md` lists them under Known gaps.
- `wait` → a QA or build is running and nothing else can start: end your turn; continue when it reports.
- **While a build runs**, call `pumori next --json --building`: it returns only check, QA or close work for
  other milestones (e.g. QA of M3 while M2's fix tasks build), or `wait`. Dispatch what it returns alongside
  the build. Without `--building`, `next` would hand you the running build's wave again.
- `blocked` → explain why in plain words and ask the human what to do (options + recommendation). Apply the
  answer with `pumori resolve <task> retry --note "<the decision>"` or `pumori resolve <task> drop`. In
  autopilot runs, decide yourself only if the Architect's unstick question has an obvious answer from the spec;
  otherwise stop and report.
- **Wrong protected test** (an unstick `replan` saying "amend test …", or a reviewer/QA finding that a test
  contradicts the spec): spawn `pumori:test-designer` with "Mode: amend <task|baseline>: <reason>", then
  `pumori:reviewer` with "Mode: test-review <target>: <reason>", then run
  `pumori amend-test <target> --reason "<reason>"` and `pumori resolve <task> retry --note "test amended"`.
  Nobody else edits protected tests (a hook enforces it).
- **Test runner config change** (a gate says "test runner config changed", or a developer's `not_done` asks
  for one): same reviewed path with target `config`: Test Designer "Mode: amend config: <change>", Reviewer
  "Mode: test-review config", `pumori amend-test config --reason "…"`. Never ask the human for this.
- **`env_blocked` with stage `main-red` or `circuit-open`** (main itself fails tests that should pass, or several
  tasks failed after merging within 15 min): don't retry tasks. Spawn the Architect "Mode: triage — main is red:
  <gate output>; add ONE task with `"fixes_main": true` and no deps that makes main green". Build it as its own wave (its gate
  is let through). When it merges, run `pumori gate <task>` for each blocked task. The block lifts by itself once main
  changes (`main-red`) or after 15 min / any clean merge (`circuit-open`).
- **A task reopened after its code merged** (e.g. a browser check failed for a reason since fixed, and the
  review recorder says its branch is gone): `pumori resolve <task> merged`. It runs the task's tests on
  main and marks it passed if they pass. Don't rebuild it through fresh worktrees.
- **Spec change that alters a shared contract**: the Architect adds the contract task first; ask the Test
  Designer to amend protected tests for the new shape only **after** that task merges.
- `release` → run `pumori release` yourself (Bash). It runs the final full verify, deploys staging only if
  Docker is already running (it never starts Docker), generates `HANDOFF.md` from recorded facts
  (tasks, requirement coverage, journeys, risky files, known gaps, cost) and commits it. Add a 3–5 line
  plain-English summary at the top of your message to the human (not in the file). Then `pumori stage accept`.

## accept (HUMAN CHECKPOINT 2)
Summarise `HANDOFF.md` in ≤ 15 lines: staging URL, what works, journey results, the "review these first"
list, known gaps, cost. Ask: accept / request changes (→ `/pumori:change`) / reject. On accept:
`pumori stage done`, `pumori bench-score --label "<project>"`, and tell them the factory never deploys
to production; that's their button.

## Rules
- Respect the caps (round cap, QA cycles, budget). When `next` says blocked, stop and ask; never loop around it.
- At most one build and one QA at a time. A build may run while QA runs (that's how milestones overlap);
  never two builds at once. Fix tasks from triage come back first in the next `pumori next`.
- If a workflow returns nulls/errors, re-run it once (it resumes). If it fails again, report and ask.
- Never push, never deploy to production, never change Postgres/system config.

Versions

RepositoryScoreLicence
This page · akasrai/pumori90MIT
fayssal-elmofatiche/factory-sandbox100GPL-3.0
andriiklymiuk/corgi100MIT
uiverify/uiverify100MIT
BuilderIO/skills100MIT
chrisgagne/grounded-forge100MIT
TDSchreur/tds-factory100MIT
momoathome/software-factory100MIT
hybridlabor-api/aos100Apache-2.0

Database snapshot: 13.11.2026 · package version d98953780083 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 82new
    Create a new Pumori product project from a PRD and a stack pack (default next-fastify-postgres), ready for /pumori:factory. Use when the user wants Pumori to build a new product from a PRD.
  • 100eminzo-factory
    Run the Eminzo software factory v2. A GitHub issue labeled `factory` becomes a job (with `issue <n>`, `<feature>` or `xs <request>`, or from the queue by `run` when `run_mode` is `queue`); `job new` claims it for the gh user. Each job goes through intake, routing, spec (and an…
  • 82change
    Request a change to a product Pumori already built (or onboarded) - the PM turns it into new or changed requirements and journeys, the Designer mocks any new screens, the Architect adds tasks, and the normal build/QA loop runs. Use for "change X", "add feature Y", "fix Z" on a…
  • 90factory-run
    Driver of the factory. Use this, instead of editing the code yourself or calling the factory skills one by one, whenever the user asks for a bug fix, idea or feature to be built and delivered as a pull request or taken end to end, however small the change looks (\"build it and…
  • 100skill-factory
    Run a full build-and-ship pipeline from a spec — use for hands-off project generation
  • 90review
    /factory:review <pr>. Run the Factory reviewer in this session on one PR of the current repository: one comment-only pass of line-tied findings. Use when the user asks to review a Factory PR by number.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.