mikeparcewski/wicked-garden / skills/archetype
wicked-garden-archetype
Verifiedv11 work-shape archetype runner. When a prompt has been routed to one of the archetypes (triage, explore, specify, decide, ship, review, incident, build, migrate, modernize), this skill is the entry point. It picks the right per-archetype playbook from refs/ and executes the phase shape declared in `.claude-plugin/archetypes.json`. Use when: a `<wg archetype="X">` or `<wg archetypes>` system-reminder tag appears, an explicit "let's run the X archetype" request, or a direct per-archetype ask — "triage this prompt", "review this PR / artifact", "build this feature", "decide between these options", "explore this problem", "handle this incident", "run this migration", "modernize / port this legacy app", "ship this release", "write acceptance criteria" (invoke with archetype=<name> plus the user's args — see the Direct invocation table).
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 8.0 KB |
| refs/build.md | markdown | 7.5 KB |
| refs/decide.md | markdown | 6.1 KB |
| refs/explore.md | markdown | 2.3 KB |
| refs/incident.md | markdown | 8.2 KB |
| refs/migrate.md | markdown | 9.7 KB |
| refs/modernize.md | markdown | 11.6 KB |
| refs/review.md | markdown | 9.7 KB |
| refs/ship.md | markdown | 6.1 KB |
| refs/specify.md | markdown | 5.8 KB |
| refs/triage.md | markdown | 2.7 KB |
refs/specify.md
View on GitHub# specify — turn an ask into testable acceptance criteria
When the implementation path is clear-ish but the success criteria are
fuzzy. Produces SMART acceptance criteria — Specific, Measurable,
Achievable, Relevant, Time-bound — that downstream `build` can verify.
## Phase shape
| Phase | Goal |
|----------|------------------------------------------------------------|
| elicit | Surface the user's intent through targeted questions. |
| structure | Convert intent into REQ-/AC- numbered acceptance criteria.|
| validate | Confirm with the user that the ACs match their intent. |
## Produces
- **SMART acceptance criteria** in the form `AC-N: when X, then Y`.
- One-line invariants: "A response time over 500ms is a regression".
- Optional: a `requirements.md` artifact in the project dir.
The validate gate **re-derives** this through the garden's in-process gate engine (`scripts/qe/vault_gate.py` → `scripts/loom/`, which shells `wicked-vault cross-check`): the recorded `smart-acceptance-criteria`
artifact is re-hashed and its structural verifier re-run, never trusting
a self-asserted "the ACs are testable". The gate engine ships inside wicked-garden; wicked-vault (the evidence backend) is the one **required** peer (installed by the `wicked-garden-core` skill's `setup` action); if the engine cannot resolve — or the vault behind it is absent — the gate **fails closed** (`gate: "unavailable"`, `satisfied: false`) rather
than claiming a PASS. `--no-require` opts a throwaway/low-rigor run back
to the doctrine-light claim-only path. This is a discrete (light) gate —
the deterministic check proves *shape* (each AC is measurable); if the
AC *quality* needs an independent sign-off, the judgment tier
(`wicked-vault analyze-evidence` / `--with-attestations`) is available.
## HITL
`discrete:validate-gate` — the validate phase is a hard checkpoint. Don't
proceed past validate without explicit user agreement on the AC set.
## How to run
### elicit
1. Use `/wicked-garden-product elicit` if requirements analysis is needed,
or jump in directly when the surface is small.
2. Ask 3–5 questions. Each should be answerable in one line and target a
specific dimension: scope, success metric, failure mode, edge case,
non-goal.
3. **Don't ask open-ended "tell me more about X".** Force the user to pick
between concrete options.
### structure
1. If a vault is resolvable
(`wicked-garden run scripts/qe/vault_gate.py resolve` → `available: true`), declare the
re-derivable contract for this phase so the validate gate has a bar to
check against: `wicked-vault init` (once per repo) then
`wicked-vault declare-contract --scope <scope> --phase specify --spec contract.json`
— `required_evidence` should pin `smart-acceptance-criteria`
(kind `spec-doc`) to a `regex_match` verifier proving the criteria are
testable/measurable (e.g. each AC carries a measurable assertion or a
Given/When/Then shape). Skip silently if no vault.
2. Convert each elicited fact into one acceptance criterion: `AC-N: when
<trigger>, then <observable>`.
3. Add invariants for things that should NOT change: `INV-N: <thing> must
stay under <threshold>`.
4. Keep ACs minimal — 3–7 is the sweet spot. More than 10 means you're
treating ACs as design.
5. Record the AC artifact as re-derivable evidence (vault present;
**wicked-vault ≥ 0.8.0** <!-- vault-floor -->):
`wicked-vault record --scope <scope> --phase specify
--claim smart-acceptance-criteria --kind spec-doc
--artifact <path/to/requirements.md>
--criteria "<the testability bar>"
--verifier regex_match:'(?im)^(AC|INV)-\d+:'
--actor "${WICKED_VAULT_ACTOR:-garden-prove}" --run`. The **`--actor`**
records under an explicit identity so that if AC quality needs an
independent sign-off (the optional `--with-attestations` judgment tier
above), the vault will let that attestation through instead of
refusing it as a weak/ambient identity (fail-closed since 0.4.0). The verifier re-runs against
the artifact later — a claim you can't re-derive is not evidence. No
vault → fall back to the claim-only path.
### validate
1. Show the user the AC list.
2. Ask: "is anything missing? is anything wrong? is anything overspecified?"
3. **Hard gate**: do not exit specify until the user explicitly approves the
AC set. "Looks good" is enough; silence is not.
4. If they want changes, loop back to elicit or structure as appropriate.
## When to stop
Specify is done when the user has signed off on the AC list AND the
produces-gate is satisfied. Check the gate — don't self-assert it:
`wicked-garden run scripts/qe/prove.py <claim> --by "<command>" --scope <scope> --phase specify` (frictionless, single claim — re-derive, don't assert) — or the full multi-claim contract via `wicked-garden run scripts/qe/vault_gate.py gate <project_dir> --scope <scope> --phase specify`
(exit 0 = satisfied). This is a re-derived PASS over the declared
contract: the AC artifact is re-hashed and its structural verifier
re-run. A REJECT means the recorded ACs don't clear the testability bar —
fix the criteria, not the claim. An `unavailable` verdict means the
required vault isn't installed — run the `wicked-garden-core` skill's `setup` action. Then hand off
to `build` (when the next step is implementation), `decide` (when you've
uncovered competing options), or `explore` (when the act of writing ACs
revealed the problem isn't well understood).
## Anti-patterns
- **Don't write design inside ACs.** "AC-1: implementation uses Redis"
is a design choice, not an acceptance criterion. Use `decide` for that.
- **Don't merge multiple criteria into one.** Split them so each is
individually testable.
- **Don't auto-pass the validate gate.** The whole point is the user
agrees this is what they wanted.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |