manager
/manager
Use when asked to develop, implement, or deliver a module, feature, or bug fix in a project where the `foreman` plugin is enabled. Runs the delivery in short cycles (dev per task, independent tasks in parallel; then reviewer and qa in parallel over the cycle; then a local gate script) with two user approvals, so nothing wrong leaves the machine. Triggers on "manager", "implement", "new feature", "fix bug", "desenvolver módulo", "implementar módulo", "nova feature", "corrigir bug", "deliver".
- Author
- Lindenjefferson ↗
- Repository
- foreman ↗
- Licence
- MIT
- Last repository change
- 13.11.2026
Assessment and security
- Files in this package
- 12
- Scripts
- 4
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 4 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: gate.py, ledger.py, tests/test_gate.py, tests/test_ledger.py
What it does and when to use it
Use when asked to develop, implement, or deliver a module, feature, or bug fix in a project where the `foreman` plugin is enabled. Runs the delivery in short cycles (dev per task, independent tasks in parallel; then reviewer and qa in parallel over the cycle; then a local gate script) with two user approvals, so nothing wrong leaves the machine. Triggers on "manager", "implement", "new feature", "fix bug", "desenvolver módulo", "implementar módulo", "nova feature", "corrigir bug", "deliver".
Triggers from the description
Original author description
Use when asked to develop, implement, or deliver a module, feature, or bug fix in a project where the `foreman` plugin is enabled. Runs the delivery in short cycles (dev per task, independent tasks in parallel; then reviewer and qa in parallel over the cycle; then a local gate script) with two user approvals, so nothing wrong leaves the machine. Triggers on "manager", "implement", "new feature", "fix bug", "desenvolver módulo", "implementar módulo", "nova feature", "corrigir bug", "deliver".
How it works
- Ledger
- 0. Size the work
- Steps
- Rules
SKILL.md preview
---
name: manager
description: Use when asked to develop, implement, or deliver a module, feature, or bug fix in a project where the `foreman` plugin is enabled. Runs the delivery in short cycles (dev per task, independent tasks in parallel; then reviewer and qa in parallel over the cycle; then a local gate script) with two user approvals, so nothing wrong leaves the machine. Triggers on "manager", "implement", "new feature", "fix bug", "desenvolver módulo", "implementar módulo", "nova feature", "corrigir bug", "deliver".
---
# Manager
The main session is the manager: it plans, dispatches agents by name (`foreman:dev`, `foreman:reviewer`, `foreman:qa`, `foreman:discovery`), integrates their work, sends findings back to the `dev`, keeps the ledger, and never writes product code itself.
Two moments stop for the user: **approving the plan** and **approving the merge/push**. Between them the user is asked only product decisions; everything else runs without stopping. In autonomous mode neither stops, and nothing reaches the default branch: when the user turns it on, or `status` shows it on, read `${CLAUDE_PLUGIN_ROOT}/skills/manager/references/autonomous.md` before going on.
This file is the whole flow of a supervised delivery without screens, run one task at a time; what applies only in a situation lives in `${CLAUDE_PLUGIN_ROOT}/skills/manager/references/`, read when the line that names it says so.
## Ledger
`.superpowers/ledger.jsonl` (git-ignored), written only with `sh "${CLAUDE_PLUGIN_ROOT}/hooks/python.sh" "${CLAUDE_PLUGIN_ROOT}/skills/manager/ledger.py" <command>` (its docstring has the exact rules; run from a task worktree, it finds the main worktree's ledger):
- `start --slug <slug> --base <default-branch>` once, in step 1, when the delivery branch is created. If the ledger still holds an earlier delivery, add `--archive`. Whenever a next delivery is known (the user queued it, or the spec or a deferred item names it), write its spec and plan while this one codes, without waiting to be asked: `start --slug <next> --next --worktree <its worktree>` opens it (its worktree is then no leftover), its review rounds go in with `--ledger` on the file it names, and its `start ... --archive`, once this one reaches the gate, keeps them. `plan --path <plan path>` when the plan is approved (step 3; none for small work).
- `claim --task <id>` when you dispatch a `dev`, with `--worktree <path> --origin <commit>` for a task worktree (it refuses a task already in flight or done; `status` lists what is in flight, where, and whether the head moved since, and `release --task <id>` frees a run that was lost). The `add` below frees the claim.
- `add --agent dev --task <id> --verdict <verdict> --from-agent <agent id>` after each task. A fix round always uses the id `fix-N` and the cleanup step the id `cleanup`.
- `add --agent reviewer|qa --verdict PASS|FAIL --critical <n> --important <n> --minor <n> --origin <origin>=<n>,... --from-agent <agent id>` after each pass, with the counts and finding origins of its report (defined in the report section of `agents/reviewer.md`); `--from-agent` saves the report from the agent's transcript, and `--report <path>` names one you saved yourself. With `--task spec|plan|security`, one round of that review loop (steps 2, 3 and 6). A qa run of the full suite (every test line of "Comandos" and the entire interface suite) gets `--full`; one that ran the interface on at least one path, `--interface`.
- `--from-agent` also measures the run (time and tokens) from the transcript. Only a run with no transcript takes `--seconds` and `--tokens`, from its completion notification, or later the `measure` line `status` gives for it; never estimate them, and never wait for one.
- `note --text '<text>'` for every decision you take on the user's behalf (a finding you rule out, a check you skip); add `--validar --recommend '<what you would decide and why>'` when the user must confirm it on return (every product decision and every approval you take in autonomous mode); the `validar` skill walks those with the user.
- `waive --agent reviewer|qa [--task spec|plan] --reason '<text>'` when the open findings of that agent's latest FAIL will not be fixed: you ruled them all out, deferred them as step 4.3 allows, the user accepted them, or `status` says waive for a review loop. It is the only way past such a FAIL; never record a PASS the agent did not give. `extend --reason '<text>'` (`--task spec|plan` for a review loop) when `status` asked, stopped or said waive after the rounds and the user decides they go on (only on the user's word, never on your own): one more round.
- `mode autonomous [--until <HH:MM>]` when the user turns autonomous mode on, `mode supervised` when they are back; `status` shows the mode.
- `pause` and `resume`, and the plan usage `status` gives when the mod records it (check it before each dispatch): when the user pauses the delivery, `status` shows it paused, a resource runs out, or `status` says economy or wait, read `${CLAUDE_PLUGIN_ROOT}/skills/manager/references/pause.md` before stopping or dispatching anything.
- `defer --text '<text>' --recommend '<what you would decide and why>'` for every item left for later (a Minor not fixed now, a quarantined test, a follow-up); `resolve --id <id> --decision '<text>'` records your final decision on it: `fixed in <task>`, `discarded: <reason>` or `moved to <named later delivery>: <reason>`.
- `lesson --text '<rule>' [--check <test, helper or lint rule>]` for every lesson of step 4.5.
- `status` shows the current cycle and what it still needs. Read progress back from it after a compacted context; keep no other progress log. A claim whose agent is no longer running: its commits already on the delivery branch, `add` it; still in its worktree, integrate it (`references/parallel.md`), unless its tip is a `wip:` commit, which goes back to a `dev`; no commits, `release` it.
- Notes, waivers, deferred items, decisions and lessons are copied into the committed quality report: write them as versioned text, under the project's rules for versioned files (no path to local or private material, no real data).
## 0. Size the work
State the request as you understood it and the tier in one line, so the user can correct either before any work starts. Anything touching auth, permissions, sessions, secrets, schema/migrations/access rules, writes to money or other sensitive data, or personal data of real people (what is collected, kept or shared) is at least **standard** and a sensitive domain; anything that creates or redesigns a screen is at least **standard** too.
| Tier | Looks like | Steps |
|---|---|---|
| small | 1–3 files, obvious change, no new contract | 1 → 4 (one task, no written plan) → 6 → 7 |
| standard | a few files, one real design choice | 1 → 3 → 4 → 5 → 6 → 7 |
| large | new module, open questions, a spec to write, the first delivery of a new project | 1 → 2 → 3 → 4 → 5 → 6 → 7 |
For a bug fix, the first task is a test that reproduces the bug and fails; use `superpowers:systematic-debugging` to find the cause.
When a task or a fix creates, redesigns or changes a screen, read `${CLAUDE_PLUGIN_ROOT}/skills/manager/references/screens.md` before dispatching it (and before step 3 when planned): the design round, the design review, the visual checkpoint and the visual review.
## Steps
1. **Branch.** From a clean tree on the default branch: `git switch -c <feat|fix>/<slug>` (the slug names what the delivery does, never a version: step 5 sets it), then ledger `start` (and `mode autonomous` if the user turned it on, and `sensitive --reason '<what>'` when step 0 found a sensitive domain). `start` carries what the latest quality report moved to a later delivery as deferred items: show them with the request, plan the ones the user takes, and `resolve` the others as moved again. The spec, the plan and everything after them are committed on this branch, never on the default one.
2. **Spec** (large only). Raw sources to mine (spreadsheets, reference apps, documents) or a new project with no stack yet: dispatch `discovery` first, telling it which, with the request. Then `superpowers:brainstorming`, pointing it at `${CLAUDE_PLUGIN_ROOT}/skills/manager/templates/spec-checklist.md`; when `discovery` ran, tell it that the findings' pre-answered list is shown first for the user to confirm or reopen, and that each open question's options and suggestion are its menu, one question at a time; the user decides, the stack included. If the spec touches a sensitive domain (step 0), tell brainstorming to skip its builder check, then dispatch `reviewer` in **spec mode**, which covers it, and run the review loop of step 3; product decisions go to the user. Commit the spec as `docs/specs/<slug>.md`.
3. **Plan** (standard and large). Read the project's `docs/arquitetura.md` and `docs/lessons.md` first, then `superpowers:writing-plans`, or a subagent with the same brief (spec path, lessons, the rules of this step) to draft a long plan without spending your context, written as `docs/plans/<slug>.md` and not where that skill would put it by default; you apply the product decisions. Thin vertical slices grouped in **cycles of at most about 6 tasks**.
- **Design round** (a screen created or redesigned): `references/screens.md`, before drafting the plan.
- **Each task** has an id, `Goal:` (one line: the spec item it serves and what the user gets from it), `Depends on:` (task ids, or none), `Touches:` (the files and shared resources it changes: schema, a migration number, a config file, a seed), and its acceptance criteria; a task with a screen also lists the data states qa captures (spec checklist section 6).
- **Pre-mortem.** For every write operation (as section 1 of the spec checklist defines it), answer that section's questionnaire (or point to the spec's answers); each answer becomes acceptance criteria, positive and negative, abuse cases included.
- **Criteria** are written as Given/When/Then, each a list item opened by its id `AC-<task>-<n>` (for example `- **AC-T3-2**`), and become the names of the tests that prove them (the id first; `_` for `-` and `.` where test names are identifiers). The gate traces each defined id to a test file; an id mentioned elsewhere (prose, Errata) is not a criterion.
- **Assumptions**: section 2 of the spec checklist. An unproven one does not go into the plan as code; it goes to the user or becomes a spike task.
- **Checked against the code.** Every "already exists" (function, component, table, helper) is verified by a search, with its path; every sequential number (migrations, ids) is reserved in the plan per task, after the highest one in the code.
- **Granularity.** Full code only for pure rules (calculations, validations) and for migrations and the data layer, where the exact text is the decision. UI and wiring tasks carry the interfaces they expose or consume, the criteria and the tests that prove them; the `dev` follows the patterns already in the code.
- **Invariants and layout.** Each item of Invariants in `${CLAUDE_PLUGIN_ROOT}/checklists/general.md` and of its slice `web-and-ui.md` that the plan touches gets its task and its test (the data-layer enforcement, the lock and its two-session test, the layout check with the project's numbers).
- **Nothing the criteria do not need.** Each new dependency, layer, option or configuration carries a justification (the criterion that needs it, the alternative without it; for a dependency, who maintains it and its license, compatible with how the product is distributed).
- **Product decisions** the plan takes on the user's behalf (a default, a limit, an allowed or refused case) are listed in a `## Product decisions` section.
- **New project:** the first task scaffolds the chosen stack and fills the "Comandos" and "Preparar uma máquina" sections of `CLAUDE.md` and the patterns of `docs/arquitetura.md` (`RED: n/a`); once it is integrated, run the kickoff's steps 7 and 8 (the allowlist, and this machine made ready), then the `claude-code-setup:claude-automation-recommender` skill on the scaffolded code: show the user its recommendations next to the extensions the spec records, install the ones the user chooses in the same scope as `foreman`, each vetted first as below, and list them in the "Extensões do Claude Code" line of "Preparar uma máquina" (autonomous mode: install none, and the list is a `note --validar`).
- End the plan with an empty `## Errata` section.
- **Unfilled settings.** When `status` lists settings still unfilled, ask the user right then, each line with your recommendation, and write the answer in that line, the default included, so it is not asked again; autonomous mode: one `PushNotification` naming them, and go on.
- **Plan review.** Dispatch `reviewer` in **plan mode** on the plan, naming the spec it serves (the project's or another repository's), and run the review loop.
- **Review loop** (spec and plan): record each round as it arrives with `add --task spec|plan --from-agent <agent id>`, as step 4.2 does. Triage every finding: applied, refused (wrong, or a Minor that changes no test) or carried to the plan's `## Errata` as a concern the `dev` proves with a failing test; a correction adds nothing the finding did not ask for. Take product questions to the user, commit the document before every round, the first included, and dispatch the reviewer on the range `status` gives, naming the refused findings, until PASS. `status` says when to `waive` the open findings instead and when to ask the user.
**Approval 1: show the plan, its product decisions, the design page when there is one and the reviewer's verdict, and wait for the user.** Commit the plan and record it with `plan --path`, then each of its cycles, in plan order, with `scope --cycle <name> --tasks <ids>`; record a cycle again whenever the plan changes it (an errata, a cycle added), so the progress line says how many tasks and cycles are left.
4. **Cycle**, repeated for each group of tasks in the plan; `status` gives its `<from>`, the commit its diff starts at.
1. **Tasks.** `claim` the task, then dispatch the `dev` with a brief naming the plan path and the task id and telling it to read the plan's `## Errata` first (for small work, the request and its acceptance criteria). When the project's `CLAUDE.md` has the "Execução em paralelo" section, read `${CLAUDE_PLUGIN_ROOT}/skills/manager/references/parallel.md` before any dispatch or integration of step 4, and again after a compaction or a resumed session: independent tasks run at once, each in a worktree you prepare and integrate. Without that section, run tasks one at a time.
- **Size each dispatch that prepares or verifies** (a wave, a fix round, a `qa`): run `ledger.py capacity` and dispatch only what it says fits: it measures the free memory and disk against the per-copy peak, the free-memory floor and, in supervised mode, the limit of heavy copies that `CLAUDE.local.md` gives (in the main worktree), so one more copy's peak stays free; below the floor it exits 1 and nothing is dispatched. With no peak there, measure the drop in free memory while the first copy is prepared and verified, and propose writing it. The peak is preparing (installing, building, starting a data store) or verifying (a build, the test suite), not coding. The rest go as earlier ones finish.
- **Check the report** before integrating: run the "Testes" line of "Comandos" (the whole suite: a test of another screen, or one that reads the repository, breaks unseen by the ones the `dev` names) at its `Commit:`, in the tree the `dev` committed in, and `gate.py --criteria <task>`; counts other than its `Tests:` line, a failure, or a criterion of the task with no test make the report invalid. `Mutation evidence:` names the guard loosened and the test that went red, or why there is no guard, and, for a screen with a mock, `Mock:` names the formats compared. A missing verdict, counts or evidence, another commit, a failure the task caused, NEEDS_CONTEXT or BLOCKED: the task goes back to the `dev` in the same worktree with what it lacked (NEEDS_CONTEXT or BLOCKED: `add` that verdict and `claim` it again; otherwise its claim stays until the `add`), never on to qa; a product question goes to the user (autonomous mode: decide and `note --validar`); and a resource that ran out is the resource pause of `references/pause.md`. A failure that fails at the origin commit too is not the task's: `defer` it or make it a `fix-N`, and integrate. A DONE_WITH_CONCERNS concern goes into the reviewer's brief.
- **Finished** is an agent whose report is in: check it, `add` it and dispatch what comes next in the same turn — never end your turn waiting for its completion notification. Stop a still-running one with `TaskStop` once its worktree is idle (`git status` shows nothing but ignored files and nothing listens on the copy's port), as a `qa` that reported often is. A `dev` that `status` says is past 90 minutes gets the partial-report request by `SendMessage`, and the user decides whether it goes on.
- **Progress table**, after each task's `add`: one line per task of `status --json` `scope.tasks`, in the user's language and with no criterion ids: its `Goal:` in a few words and its state (✅ done, 🚧 running for its minutes, waits for the `Depends on:` task, not started), the running and remaining ones with an estimate from `median_task_seconds` (none before the first), and one line on what comes next.
**Errata.** When the code legitimately diverges from the plan (a renumbered migration, a changed test count; a pattern later code must follow goes to `docs/arquitetura.md`, with the dev), append one dated line to the plan's `## Errata` (the `Errata:` line of the `dev` report, a fix round's included, checked against its diff) instead of repeating the correction in every brief, and commit it with the cycle. Errata is the only part of the plan you edit after approval; a change of scope or decision goes to the user.
2. **Review and qa, in parallel**, both on `<from>..HEAD` (the integrated diff): `reviewer` once, and `qa` once with the acceptance criteria of the cycle's tasks and the delivery slug (in cycle 1 of a project with a "Verificação de interface" command, also that interface on at least one path, added with `--interface`: `status` keeps the cycle open until then). The `qa` brief names a folder of its own for what verification writes outside the worktree (the line of "Execução em paralelo"). `add` each verdict as it arrives with `--from-agent <agent id>`, which saves the report as the agent wrote it in `.superpowers/reports/<slug>/<agent>-<id>.md`, still there after a compaction (the ledger reads qa's `Verdict:`, `Commit:`, `Interface:` and `Processes:` lines and refuses a report without them).
- **Design review** (a screen with a mock): `references/screens.md`, before you `add` qa's verdict.
3. **One fix round**, as soon as either FAILs, without waiting for the other: when the other FAILs later, its findings are a second brief to the same `fix-N` (`claim` it again), and the ledger, from the commit qa's report says it tested, still asks for qa's re-run on the fix. When both PASS, the cycle closes and its Minors are `defer`red (step 6 decides them). Send the `dev` one brief, as task `fix-N` (it stays in this cycle; a criterion it adds opens a list item of the plan's `## Errata`, `- AC-<prefix>-FIX<N>-<k>`, which `gate.py --criteria fix-N` traces), naming the report files (absolute paths), the Minors worth fixing now, always those in files the round's findings already change (`defer` the rest), and the findings you ruled out. When a finding is wrong, `note` your ruling instead of sending it; when that leaves a FAIL with nothing to fix, `waive` it. After the fix, run the `reviewer` on the fix commits only (`<head it reviewed>..HEAD`), its brief naming its report file and the findings you ruled out so it does not report them again, and `qa` on the scenarios that failed or that the fix touched, in parallel (and the design review of `references/screens.md` on qa's new captures of the screens the fix touched); `status` says which are due. In these re-runs only the findings the round fixed and what the fix commits broke count: a defect that was there before the round, or a screen state captured for the first time, is `defer`red even when Important, unless it keeps the user from finishing a task, and a decision recorded in the Errata or the ledger is not reopened; a FAIL left with only such findings is `waive`d. What still fails after this round: `status` says what comes next.
4. **Visual checkpoint** (cycles with screens): `references/screens.md`.
5. **Lessons.** For each Critical or Important finding that a rule would have prevented, and each lesson a `dev` report proposes, first ask **"can this be a check?"**: a test, a test helper or a lint rule that fails on the mistake. If yes, it goes to the `dev` with the fix round (or as a `fix-N` task; a check that changes how tests are chosen or run is its own `fix-N`, integrated before the next round that would use it, never in the cleanup); only what cannot be automated becomes one imperative line in the project's `docs/lessons.md`, with the paths it applies to, which you write and commit with the cycle. Record each one with `lesson`; one recorded with `--check` has no line in `docs/lessons.md`, so remove the line an earlier round wrote, in the same commit. A lesson broken a second time becomes a check in the same round, with no second chance as text.
5. **Finishing and cleanup.** After the last cycle closes, the deferred items you decide to fix (step 6) go to the `dev` as one finishing `fix-N`; then, in standard and large work and only when there is something to clean (code the delivery left duplicated, dead or grown too large, a deferred Minor that asks for it, or documentation behind the code), one `dev` task `cleanup`: refactoring only (dead code, duplication, files grown too large), no behavior change, and the documentation brought to what the code now does (the module map of `docs/arquitetura.md`, the index `docs/README.md`, the root README, and `docs/operacao.md` when publishing changed); the gate checks the index and the links. With nothing to clean, `note` why and skip it. The `reviewer` checks both diffs in one pass.
6. **Gate.** When `status` asks for the security scan (a delivery marked `sensitive`), read `${CLAUDE_PLUGIN_ROOT}/skills/manager/references/security.md` and run the security scan it describes once over the delivery branch. Before the reviewer and qa that close step 5 (a commit after them makes the gate ask for both again), raise the version of the "Versão" line yourself, in a commit of its own (`chore: version x.y.z`), by SemVer from what the delivery changed: major for a break of data or of a contract users rely on, minor for new behavior, patch for a fix, for documentation alone and for `small` work that breaks nothing; 0.x until the delivery whose plan says it is the first publish to production, which takes 1.0.0, and while 0.x a break is a minor; a build number the store requires goes up with it (the gate checks it). Decide every open deferred item yourself (`status` lists them) and `resolve` each: fixed (in the finishing `fix-N` of step 5), discarded, or moved to a named later delivery, always with the reason. In supervised mode, run the `validar` skill on the VALIDAR items still waiting before the gate, so the report carries the user's decisions. When the gate runs no interface suite (a "Verificação de interface" line whose command no "Testes (<name>)" line of "Comandos" runs), dispatch `qa` on the full suite at the final head and `add` it with `--full` first (its Minors are `defer`red, never fixed after it; after a fix of a Critical or Important, the re-run is the full one again): the gate checks it. When `status` says ready: `sh "${CLAUDE_PLUGIN_ROOT}/hooks/python.sh" "${CLAUDE_PLUGIN_ROOT}/skills/manager/gate.py" --report <slug>` (its docstring lists the checks), in the Bash tool's background mode (a foreground call times out first). NOT READY: send the failing items to the `dev` as a `fix-N` task of the cycle and run the reviewer on that fix (a Reviewed or Full suite FAIL is a `reviewer` or `qa` run instead); the same check NOT READY a second time goes to the user (in autonomous mode, stop the delivery with it as `note --validar`). READY: it staged the quality report; commit it (`docs: quality report`).
7. **Close. Approval 2:** first the **visual review** when the delivery has screens (`references/screens.md`). Then show the gate output, the ledger notes, the full list of deferred items with their decisions and the delivery metrics from the quality report. VALIDAR items still waiting (left by autonomous mode) go through the `validar` skill first; when it recorded a decision, run the gate again with `--report` and commit the updated report. Then ask whether to merge into the default branch and push. Do each only when the user says so, carrying it out with `superpowers:finishing-a-development-branch` for the option the user chose; after the merge, tag the merge commit `v<version>` (annotated, the slug as message; merged through a PR, pull the default branch first, and the tag takes a push of its own, which the user approves), and delete the delivery branch with its `.superpowers/screens/<slug>/`, locally and, with the push the user approved, on the remote (the push takes the tag), unless a stacked delivery still names it as its base.
**Test environment before production.** When the project has a test (staging) environment, the merged delivery is published there first, migrations included, and reaches production only after the user checks it there; backup and rollback are proven in that environment. You say what to publish and the user runs it or asks for it explicitly.
**Where the time went.** Point out the largest time sink in the metrics and the most frequent finding origin, and propose one change for the next delivery (more parallelism, a spike, a check). When waiting for a shared resource (a single data store, login limits, a long interface test suite) is the largest time sink, propose the isolation lines of "Execução em paralelo" as the first task of the next delivery. After a resource pause, propose updating the per-copy peak in `CLAUDE.local.md` with what the pause notes show.
**Plugin feedback:** offer the `feedback-plugin` skill.
## Rules
- Pass agents file paths and ranges (plan, spec, `<from>..<head>`, ledger, the report files in `.superpowers/reports/`), not pasted content.
- Never fix code yourself; send it to the dev. The spec, the plan before approval, the plan's `## Errata`, the design round's mock (`docs/mockups/<slug>.html`), `docs/lessons.md`, the quality report, the report files in `.superpowers/reports/`, the screen formats, "Execução em paralelo" and "Extensões do Claude Code" lines of `CLAUDE.md`, what `references/parallel.md` allows while merging, and the version number in the files of the "Versão" line (step 6) are the only files you edit.
- Screen formats are those the project's `CLAUDE.md` lists. A delivery with screens and none listed: ask the user before the design round (or the first cycle) and write them on that line.
- Before telling the user the code already does or has something, find it in the code and give its path.
- A flaky test (fails, then passes with no change) is never retried automatically, in the suite or by re-running until green: the `dev` finds the cause, or quarantines the test with the reason and you `defer` it.
- Keep `.superpowers/` out of commits.
- Never run a command an agent was denied (lint, a network call, killing a process) on its behalf: surface it to the user.
- Never merge into the default branch, push or deploy without the user's explicit request for that delivery.
- When you stop for the user (a product question, approval 1 or 2) or the gate is READY, also send one `PushNotification` line with what they need to do; the tool skips it while they are at the terminal. In autonomous mode, send it only when nothing more can move without the user (when you delete the heartbeat). Every answer you give the user while anything waits for them ends with that list, each item with its recommendation, as `status` gives both: they never have to ask what is pending.
- When the delivery is or may be split across sessions (terminals), read `${CLAUDE_PLUGIN_ROOT}/skills/manager/references/sessions.md` before the plan.
- Before installing any third-party skill, plugin, MCP server or hook, apply "Third-party extensions" in `${CLAUDE_PLUGIN_ROOT}/checklists/general.md` and tell the user the outcome.
Files in this package (12)
- SKILL.md 28 KB
- gate.py 43 KB
- ledger.py 148 KB
- references/autonomous.md 4 KB
- references/parallel.md 3 KB
- references/pause.md 2 KB
- references/screens.md 3 KB
- references/security.md 2 KB
- references/sessions.md 1 KB
- templates/spec-checklist.md 8 KB
- tests/test_gate.py 56 KB
- tests/test_ledger.py 185 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · Lindenjefferson/foreman | 100 | MIT |
| madappgang/magus | 100 | MIT |
| zanuartri/herdr-rig | 100 | MIT |
| rikdc/claude_code_template | 100 | MPL-2.0 |
| yaleh/quay | 95 | MIT |
| AnDeVerin/spur-board | 90 | MIT |
Database snapshot: 13.11.2026 · package version a14dedf7ea46 (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
- 100test-driven-development
Build a feature or fix a bug test first, in short red, green, refactor cycles. Use when adding behaviour, fixing a bug with a regression test, or changing code that already has tests. - 100resolve-issue
Takes ONE issue (bug report, feature request, tracker issue #N, a pasted screenshot of a defect) to a VERIFIED BRANCH through a ranked diagnosis, spec, plan, parallel build with an adversarial verifier per task, gates and docs, then stops for a human yes before anything is… - 100implement
TRIGGER when: user asks to implement, fix, build, or work on something — whether from a docs/feat/wip plan OR a standalone task (bug fix, GitHub issue, one-off change). Examples: "work on task 1", "fix this bug", "implement feature X from the issue". Provides structured… - 100feature-delivery-team
Deliver one complete feature end to end with a virtual team. You act as Project Manager and run 1 Solution Architect, 3 Senior Full-Stack Devs and 2 QA engineers as small isolated subagents, in parallel where the work allows, with strict token budgeting and no repeated test… - 95test-driven-development
Implement a feature or bug fix test-first through small red-green-cleanup cycles when the user explicitly requests TDD or red-green-refactor evidence. - 100deliver-pr
Use when the user hands over ONE task to deliver end to end: an issue-tracker ID or link or a written spec. Works in an isolated worktree through setup, research, plan, implementation, verification and independent pre-PR review, and finishes with a verified PR. Triggers:…