Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

factory

/factory

Prowadzi fabrykę oprogramowania: funkcja przechodzi od specyfikacji przez budowę i równoległe przeglądy do zatwierdzenia i scalenia.

Repozytorium
factory ↗
Licencja
MIT
Ostatnia zmiana repozytorium
30.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 30.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi fabrykę oprogramowania: funkcja przechodzi od specyfikacji przez budowę i równoległe przeglądy do zatwierdzenia i scalenia.

Argumenty

/factory <feature> | init | next | board | spec <feature> | build <job-id> | respec <job-id> <note> | approve <job-id> | rework <
Oryginalny opis (EN)

Run the software factory. Takes a feature through spec → build → parallel reviews (security, ux, ui, code) → approval → merge, tracking every step in factory/jobs/<job-id>/state.json (job ids come from GitHub issues). Use for /factory <feature>, /factory next, /factory spec|build|respec|approve|rework <job-id>, /factory init, /factory board.

Jak działa

  1. The loop
  2. The profile
  3. Flavours
  4. Paths
  5. Rules
  6. state.json
  7. Commands
  8. Report
Sekcje z nagłówków SKILL.md, w oryginale · 395 linii, 3 002 słów
Podgląd SKILL.md
---
name: factory
description: Run the software factory. Takes a feature through spec → build → parallel reviews (security, ux, ui, code) → approval → merge, tracking every step in factory/jobs/<job-id>/state.json (job ids come from GitHub issues). Use for /factory <feature>, /factory next, /factory spec|build|respec|approve|rework <job-id>, /factory init, /factory board.
argument-hint: <feature> | init | next | board | spec <feature> | build <job-id> | respec <job-id> <note> | approve <job-id> | rework <job-id> <note>
allowed-tools: Bash(bash ${CLAUDE_PLUGIN_ROOT}/scripts/*), Bash(python3 ${CLAUDE_PLUGIN_ROOT}/scripts/*)
---

# Software factory

The session running this skill is the **orchestrator**. It runs the loop, spawns
every agent, and is the **only writer of the jobs' `state.json` files**. It never
writes product code itself.

Arguments: `$ARGUMENTS`

`FACTORY_HOME` = `${CLAUDE_PLUGIN_ROOT}` — the factory core (agents, scripts,
dashboard, templates). It changes with every version: never write into it.
Pass it to every agent as `FACTORY_HOME`.

## The loop

```
   feature ─► spec-writer ─► [stack gate] ─► builder ◄──────────────┐
                                               │                    │
                      ┌──────────┬─────────────┼───────────┐        │
                      ▼          ▼             ▼           ▼        │
                  security       ux         ui design     code      │
                      └──────────┴──────┬──────┴───────────┘        │
                                        ▼                           │
                               WAIT FOR ALL reviews ── CHANGES ─────┘
                                        │ all PASS     (max 2 rework rounds)
                                        ▼
                                     CI gate
                                        ▼
                                     approver ── ESCALATE ─► needs-human
                                        │ APPROVE                │
                                        ▼                        ▼ /factory approve
                                      merge ◄────────────────────┘
```

Agents (from this plugin): `factory:spec-writer`, `factory:builder`,
`factory:reviewer-security`, `factory:reviewer-ux`, `factory:reviewer-ui`,
`factory:reviewer-code`, `factory:approver`, and `factory:prototyper` for the
design gate. Spawn them with exactly these `subagent_type` names.

## The profile

`REPO/factory/profile.md` holds everything project-specific. Read its
frontmatter once per command (`python3 FACTORY_HOME/scripts/profile.py`):

- `flavour` — how the factory is run (below).
- `main` — the branch jobs start from and merge into (default `main`).
- `ci_workflow` — workflow file of the CI gate; `none` skips the gate.
- `lenses` — which reviewers run (always `security` and `code`).
- `ui_paths` — globs that make a rework round re-run ui/ux.
- `secret_scan` — run `FACTORY_HOME/scripts/gitleaks.sh` before every push.
- `docs.*` — AGENTS.md, NFRs, design guideline, secure-coding guideline.
- `secure_coding_rules` — the rule range the security checklist must cover.
- `issue_ids_from` — jobs below this number predate issue ids (default 1).
- `design.source` — where screens are designed: `figma`, `figcraft`,
  `prototype` or `none`; `design.file`, `design.tokens` (pinned token snapshot),
  `design.prototypes` (approved prototypes kept in the repo).

The Markdown sections of the profile are for the agents; you don't interpret them.

## Flavours

The loop is the same in every flavour. The flavour decides where a job comes
from, where a human answers, and whether you run interactively.

| | `local` | `jira` | `ticket-pr` |
|---|---|---|---|
| started by | `/factory …` in a chat | Jira label → CI | merged `docs/tasks/todo/*.md` → CI |
| human gates | AskUserQuestion in the chat | Jira comment + label, PR review | PR review |
| you run | interactive | headless (`claude -p`) | headless (`claude -p`) |

Headless (`jira`, `ticket-pr`): never call AskUserQuestion. Wherever this skill
says "ask the human", set `stage: needs-human` with a `note`, post the question
as a comment on the job's issue (and, for `jira`, on the Jira ticket via
`FACTORY_HOME/scripts/jira.sh comment`), commit and push the job folder, and
stop. The human answers with a comment that the flavour's workflow turns into
`/factory approve|rework|build|respec …`. Details: `FACTORY_HOME/flavours/<flavour>.md`
— read it once at the start of every command in a headless flavour.

## Paths

- `REPO` — `git rev-parse --show-toplevel`. The main checkout; it stays on `main`.
- `JOB_DIR` — `REPO/factory/jobs/<job-id>/`. All job markdown lives here, on `main`.
- `WORKTREE` — `REPO/.worktrees/<job-id>/`, a git worktree on branch
  `factory/<job-id>`. All product code is written and committed here, so the
  main checkout and the dashboard never change branch.
  **Multi-repo jobs** (`JOB_DIR/targets.json` lists repos, flavour `jira`): the
  jobs live in the harness repo; `WORKTREE` is a folder with one worktree per
  target, `WORKTREE/<repo>/`, each on branch `factory/<job-id>` of that repo.
- `ROUND_DIR` — `JOB_DIR/round-<n>/`.
- `STATE` — `JOB_DIR/state.json`, the job's board state.

## Rules

1. **Files, not conversation.** Agent prompts contain only the job id and the
   absolute paths above plus `FACTORY_HOME`. Everything else an agent needs is
   in files.
2. **One file per agent.** spec-writer → `spec.md`; builder → `build.md` (+ code
   in `WORKTREE`); reviewers → `ROUND_DIR/review-<lens>.md`; approver →
   `decision.md`. You write only `state.json`, `backlog.md`,
   `stack-decision.md`, `rework-<n>.md`, `targets.json`, and per round
   `ROUND_DIR/head` (the commit under review, one line per repo for multi-repo
   jobs), `ROUND_DIR/ci.md` and the review files of lenses you skip or carry over.
3. **Verdicts are the first line.** Reviews start `VERDICT: PASS` or
   `VERDICT: CHANGES`; `decision.md` starts `APPROVE` or `ESCALATE`. Read only
   the first line to route. A missing or malformed first line counts as
   `CHANGES` / `ESCALATE`.
4. **WAIT FOR ALL.** A round is done only when every lens of the profile has its
   review file in `ROUND_DIR`. Never resume the builder mid-round.
5. **One builder per job.** Spawn it with name `builder-<job-id>`; for every
   later round resume that same agent with `SendMessage`. If it can't be resumed
   (new session, headless re-run), spawn a fresh one with the same name — it
   rebuilds context from files.
6. **Max 2 rework rounds.** Reviews run in rounds 1–3. CHANGES in round 3 → `needs-human`.
7. **Update `state.json` at every transition** (the dashboard reads it), writing
   the whole file and bumping `updated`. Never write another job's `state.json`:
   one file per job means several people can run the factory at the same time.
8. **Job ids come from GitHub issues.** GitHub hands out the number, so two
   people can never pick the same id. Never derive an id from `factory/jobs/`.
9. **Tests run once, in CI.** The builder runs the suite while it works; after
   that, CI on the pushed branch is the source of truth.
10. **Model by size.** `spec.md` has a `Size:` line (`small` | `normal`). For
    `small` jobs spawn `builder` and `approver` with `model: sonnet`. The
    security reviewer always runs on its own model; any job touching auth,
    secrets or permissions is never `small`.
11. **No secrets, ever** (if `secret_scan: true`). Every push of a job branch is
    preceded by `bash FACTORY_HOME/scripts/gitleaks.sh <worktree>`. Exit 1 → do
    not push: a real credential → `stage: needs-human`, `note: "secret in branch
    — rotate"`, tell the human at once (a committed secret counts as
    compromised even if never pushed); a fake test fixture → resume the builder
    to make it obviously fake, then scan again. Exit 2 → retry; never push
    unscanned.
12. **A pushed branch is never rewritten.** Before its first push the builder
    may rebase onto `main`; afterwards it merges `main` in. Every push is a
    fast-forward; no force-push, ever.

## state.json

```json
{
  "id": "012-rate-limiting",
  "issue": 12,
  "title": "Rate limiting on the public API",
  "branch": "factory/012-rate-limiting",
  "builder": "builder-012-rate-limiting",
  "flavour": "local",
  "targets": null,
  "external": null,
  "stage": "review",
  "round": 2,
  "max_round": 3,
  "reviews": { "security": "CHANGES", "ux": "PASS", "ui": "pending", "code": "PASS" },
  "history": [ { "round": 1, "reviews": { "security": "CHANGES", "ux": "PASS", "ui": "CHANGES", "code": "PASS" } } ],
  "decision": null,
  "waiting": null,
  "note": "",
  "updated": "2026-10-14T12:00:00Z"
}
```

- `stage`: `spec` → `build` → `review` → `approve` → `merged` | `needs-human`.
- `reviews`: one key per lens of the profile; each `pending` | `PASS` | `CHANGES`.
  When a new round starts, move the finished round into `history`.
- `targets`: `null`, or the repo list of a multi-repo job (`["FWU-DE/a", "FWU-DE/b"]`).
- `external`: `null`, or the outside ticket (`{"jira": "PORTAL-512"}`).
- `waiting`: non-null while blocked on a human (e.g. `"stack decision"`).
- `note`: one line explaining the latest state.

## Commands

### Preflight (every command except `init`)

Run `bash FACTORY_HOME/scripts/check.sh` from `REPO`. If it fails, stop and
show the output; warnings you pass on in one line. Confirm the main checkout is
on `main` and `gh auth status` succeeds. Run `git pull --ff-only`. If
`secret_scan: true`, run `bash FACTORY_HOME/scripts/gitleaks.sh` on `main`; a
finding stops the factory until a human has looked at it.

### `/factory init`

Set the factory up in the current repo. Never overwrite an existing file.
1. Create `factory/jobs/.gitkeep`, `factory/backlog.md` (from
   `FACTORY_HOME/templates/backlog.md`) and `factory/profile.md` (from
   `FACTORY_HOME/templates/profile.md`, `factory_version` set to the version in
   `FACTORY_HOME/.claude-plugin/plugin.json`).
2. Fill the profile from what the repo already says: `AGENTS.md`/`CLAUDE.md`,
   `docs/`, the CI workflows (`ci_workflow`), the UI folders (`ui_paths`).
   Old local factory copies (`.claude/agents/*.md`, `.claude/skills/factory/`)
   are the best source: move every project-specific rule they hold into the
   matching profile section, then tell the human the copies can be deleted
   (don't delete them yourself).
3. Add `.worktrees/` to `.gitignore`. If `AGENTS.md` has no
   `## Application stack` section, append one with `STATUS: NOT CONFIGURED`.
4. Run the preflight, show the profile, and ask the human to review it before
   the first job. Commit only after they agree.

### `/factory board`

Start `python3 FACTORY_HOME/scripts/dashboard.py 8000` in the background and
give the human http://localhost:8000/.

### `/factory <feature>`

1. **Create the job.**
   - Open the issue: `gh issue create --label factory --title "<short title>"
     --body "<feature text verbatim>"` (create the label once with
     `gh label create factory` if missing). Its number `N` is the job number.
     In `jira`, the workflow passes the Jira key; put it in the issue title
     (`[PORTAL-512] …`) and in `external`.
   - Id = `N` zero-padded to 3 digits + `-` + a 2–4 word kebab slug
     (issue 12 → `012-rate-limiting`). `mkdir JOB_DIR`.
   - Write `STATE` with `issue: N`, `flavour`, `stage: spec`, `round: 0`,
     `max_round: 3`, all lenses `pending`. Write the feature text verbatim to
     `JOB_DIR/feature.md`; for multi-repo jobs also `targets.json`.
   - Claim it right away so teammates see it:
     `git add JOB_DIR && git commit -m "factory: claim <job-id> (#N)" && git push`
     (on rejection: `git pull --rebase`, then push).
2. **Spec.** Spawn `factory:spec-writer` with: job id, `JOB_DIR`, `REPO`,
   `FACTORY_HOME`. Wait. Check `spec.md` exists.
3. **Stack gate.** Read the `## Stack` section of `spec.md`.
   - `Status: PROPOSED`: set `waiting: "stack decision"`, show the proposal and
     ask the human to confirm or amend it. Write their answer to
     `JOB_DIR/stack-decision.md` (`CONFIRMED` or `AMENDED` on line 1, then the
     final stack). Clear `waiting`. The builder must not start before this file
     exists.
   - `EXISTING` or `NOT NEEDED`: continue.
3b. **Design gate.** Read the `## Design` section of `spec.md`.
   - `Status: NEEDED`: set `waiting: "design"` and ask the human which way:
     (a) they link a Figma or FigCraft frame → write `JOB_DIR/design.md`
     (line 1 `SOURCE: figma|figcraft`, then the link and frames) and resume
     `factory:spec-writer` to fill `## Design` with `Status: EXISTS`;
     (b) the factory prototypes it → spawn `factory:prototyper` with job id,
     `JOB_DIR`, `REPO`, `FACTORY_HOME`; wait for `prototype/README.md` line 1
     `PROTOTYPE: READY`; show the human the screenshots (and the files to open)
     and ask for approval. Changes → write `design-feedback-<n>.md`, resume the
     prototyper, ask again. Approved → write `JOB_DIR/design.md` (line 1
     `SOURCE: prototype`, `APPROVED <date>`).
     Clear `waiting`. The builder must not start before `design.md` exists.
     In headless flavours: post the question with the prototype screenshots
     attached to the issue, `stage: needs-human`, stop.
   - `EXISTS` or `NOT NEEDED`: continue.
4. **Build.** Create the worktree(s): `git worktree add .worktrees/<job-id> -b
   factory/<job-id> main` (multi-repo: clone or fetch each target into
   `.worktrees/<job-id>/<repo>` and create the branch there). Board
   `stage: build`, `round: 1`. Spawn `factory:builder` named `builder-<job-id>`
   with: job id, `JOB_DIR`, `REPO`, `WORKTREE`, `FACTORY_HOME`. Wait. Check
   `build.md` exists and `git log main..HEAD` is non-empty in at least one
   worktree; otherwise `needs-human`. Check `git merge-tree --write-tree main
   factory/<job-id>`; on conflict resume the builder to rebase onto `main`
   (only while the branch was never pushed; afterwards merge `main` in). Secret
   scan (rule 11), then push the branch(es) so CI starts while the reviews run.
5. **Review round n.** `mkdir ROUND_DIR`, write the reviewed commit(s) to
   `ROUND_DIR/head`. Board `stage: review`, all lenses `pending`. Decide which
   lenses run:
   - **No surface → skip.** If `spec.md` `## Surfaces` says the job has no
     user-facing UI, do not spawn `ui` / `ux`; write their files yourself:
     line 1 `VERDICT: PASS`, line 3 `N/A — no user-facing surface (skipped by
     orchestrator per spec ## Surfaces).`
   - **Rework rounds (n ≥ 2) → only what changed.** Re-run a lens if it said
     CHANGES last round, or if the round diff (`git diff --stat
     <previous head>..HEAD`) touches it: ui/ux = the profile's `ui_paths`;
     security = anything outside docs, `*.md` and test-only files; code =
     anything. A lens that is not re-run gets its file written by you: line 1
     `VERDICT: PASS`, line 3 `Carried over from round <n-1>; the round diff
     does not touch this lens.`
   Spawn the remaining reviewers **in one message, in the background**, each
   with: job id, `JOB_DIR`, `REPO`, `WORKTREE`, `ROUND_DIR`, `FACTORY_HOME`. As
   each finishes, read the first line of its file and update that chip. If an
   agent finished but its file is missing, re-spawn it once; still missing →
   `needs-human`. If the profile names `docs.secure_coding`,
   `review-security.md` must contain `## Secure-coding checklist` with a row
   for every rule of `secure_coding_rules`; if not, re-spawn once; still
   incomplete → count it as `CHANGES`. A carried-over security review keeps its
   checklist.
6. **WAIT FOR ALL**, then route:
   - all PASS → **CI gate** (skip if `ci_workflow: none`): wait for the run of
     the commit in `ROUND_DIR/head` on `factory/<job-id>` (`gh run list
     --workflow <ci_workflow> --branch factory/<job-id> --commit <sha>`, then
     `gh run watch --exit-status`; per repo for multi-repo jobs). Write
     `ROUND_DIR/ci.md`: line 1 `CI: success` or `CI: failure`, then run URL(s)
     and each failed job with the tail of its log. Failure counts as CHANGES
     (next bullet). A clearly infrastructural failure may be re-run once
     (`gh run rerun --failed`). Success → step 7.
   - any CHANGES and `round < max_round` → push the round to `history`,
     `round += 1`, `stage: build`, then `SendMessage` to `builder-<job-id>`:
     "Round <n> reviews are in <ROUND_DIR> (and `ci.md` if CI failed). Address
     every CHANGES item, re-run the tests, commit, and append a `## Round <n>
     response` to build.md." Wait, scan, push, go to step 5.
   - any CHANGES and `round == max_round` → `stage: needs-human`,
     `note: "CHANGES after 2 rework rounds"`. Stop.
7. **Approve.** If `spec.md` `## Surfaces` says `Human gate: yes`, skip the
   approver: `stage: needs-human`, `decision: "ESCALATE (human gate)"`, and ask
   the human with a short summary from the reviews and `ci.md`. Otherwise board
   `stage: approve`, spawn `factory:approver` with job id, `JOB_DIR`, `REPO`,
   `WORKTREE`, the latest `ROUND_DIR`, `FACTORY_HOME`. Line 1 of `decision.md`:
   - `APPROVE` → **Merge**.
   - `ESCALATE` → `stage: needs-human`, `decision: "ESCALATE"`, `note` = the
     approver's reason. Comment it on the issue. Stop; tell the human about
     `/factory approve` and `/factory rework`.

### Merge (shared by APPROVE and `/factory approve`)

In `jira` and `ticket-pr` the factory does not merge into `main` itself: open a
PR per repo (`gh pr create --base main --head factory/<job-id>`, body = the
spec's problem, the AC table from build.md and the decision; multi-repo PRs as
drafts with the merge order), set `stage: merged` once they are open, and let
humans merge. In `local`:

1. From `REPO` on `main`: `git merge --no-ff factory/<job-id> -m "factory: merge
   <job-id> — <title>"`. On conflict: `git merge --abort`, `stage: needs-human`,
   `note: "merge conflict"`, stop.
2. `git worktree remove .worktrees/<job-id>` and `git branch -d factory/<job-id>`.
3. If `main` had moved past the branch's merge base (not a plain fast-forward
   of the CI-tested commit), run the AGENTS.md test command on `main`; else
   skip it, the push to `main` runs CI again. On failure put the tail in
   `note` (the job is still merged; tell the human). Delete the remote branch.
4. If the job has an approved prototype and the profile names
   `design.prototypes`, copy `JOB_DIR/prototype/` to
   `<design.prototypes>/<job-id>/` on `main`, so the next jobs build on it.
5. Board `stage: merged`. Commit the job records:
   `git add JOB_DIR && git commit -m "factory: record <job-id> (closes #N)"` and push.

### `/factory spec <feature>`

Like `/factory <feature>`, but stop after step 3. Set `waiting: "spec review
(human)"`, `note: "Spec written; build not started on purpose"`. Commit and push
the job folder. The human reads the spec, then runs `/factory build` or
`/factory respec`.

### `/factory build <job-id>`

Only for a job with `stage: spec` and an existing `spec.md`.
1. If `## Stack` is `PROPOSED` and `stack-decision.md` is missing, run the stack gate first.
2. Check the `Depends on` jobs named in `feature.md`/`spec.md`. If one is not
   `merged`, ask the human whether to build anyway; never stub another job's
   service silently.
3. Clear `waiting`, continue with step 4 (Build).

### `/factory respec <job-id> <note>`

Only for `stage: spec`. Append the note to `JOB_DIR/stack-decision.md` under
`## Spec review <n> (human)` (create it with line 1 `AMENDED` if missing; it
overrides `spec.md`). Resume or respawn `factory:spec-writer`; keep `waiting:
"spec review (human)"`, `note: "Spec revised after review <n>"`, commit, push.

### `/factory jira <KEY>` (flavour `jira`, headless)

Read the ticket with `bash FACTORY_HOME/scripts/jira.sh get <KEY>`. The feature
text is its summary plus description; the target repos come from
`FACTORY_TARGETS` (set by the workflow from the ticket's repo labels), else the
current repo. If a job with `external.jira == <KEY>` already exists, continue it
instead of creating a new one. Then run `/factory <feature>` as usual, with
these additions (details in `FACTORY_HOME/flavours/jira.md`):
- at claim: `jira.sh comment <KEY> "Factory job <job-id>: <issue URL>"`,
  `jira.sh transition <KEY> "<profile jira.status_in_progress>"`;
- at every `needs-human`: comment the question on the issue and the ticket;
- at merge (PRs open): comment the PR links, transition to
  `jira.status_review`, remove the label `jira.label`.

### `/factory ticket <path>` (flavour `ticket-pr`, headless)

The feature text is the file `<path>` (a merged `docs/tasks/todo/<slug>.md`).
Run `/factory <feature>`; at merge, move the file to `docs/tasks/archived/` in
the job's PR.

### `/factory next`

Take the first `- [ ]` item in `factory/backlog.md`. Mark it `- [~]` and run
`/factory <item text>`. When the job ends, mark it `- [x]` and append
` → <job-id> (<stage>)`. No unchecked items → say the backlog is empty.

### `/factory approve <job-id>`

Only for a job in `needs-human`. The command itself is the human's approval.
Set `decision: "APPROVE (human)"` and run **Merge**.

### `/factory rework <job-id> <note>`

For a job in `needs-human`. Write `<note>` to `JOB_DIR/rework-<round>.md`. Set
`max_round = round + 3`, `round += 1`, push the old round to `history`,
`stage: build`, clear `decision`. Recreate the worktree if it was removed.
Resume (or respawn) `builder-<job-id>`: "Human feedback is in
<JOB_DIR>/rework-<old round>.md. Address it, re-run the tests, commit, and
append a `## Rework` section to build.md." Then continue from step 5.

### Natural-language use

The human may give these commands in plain words ("bau 010", "überarbeite die
Spec von 011: …", "gib 005 frei"). Map them to the commands above and confirm
in one line which command you are running before you start.

## Report

End every command with a short summary: job id, final stage, rounds used, and
the board hint `/factory board`.

Wersje

RepozytoriumWynikLicencja
Ta strona · janrenz/factory100MIT
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

Migawka bazy z 13.11.2026 · wersja paczki 5b083dc9f494 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100eminzo-factory
    Prowadzi fabrykę oprogramowania Eminzo: zgłoszenie z etykietą factory staje się zadaniem, przechodzi przez specyfikację, budowę, bramki i przeglądy do scalonego PR.
  • 90factory-run
    Prowadzi poprawkę albo funkcję przez fabrykę aż do PR i pokazuje, co czeka na decyzję właściciela.
  • 100review
    Uruchamia recenzentów fabryki bez zlecenia: na bieżącej gałęzi lub PR, w czacie lub CI, pod kątem bezpieczeństwa, kodu, UX i UI.
  • 100ngvu-factory
    Prowadzi fabrykę oprogramowania zespołu: od zgłoszenia w Jira przez specyfikację i budowę do przeglądu i zatwierdzenia.
  • 100skill-factory
    Uruchamia pełny potok budowy i wysyłki z specyfikacji, do generowania projektów bez ręcznego nadzoru.
  • 100factory-orchestrate
    Prowadzi fabrykę end-to-end: od pomysłu przez specyfikację, zadania i równoległe wdrażanie do przeglądu innym modelem i scalenia.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.