Skills Reference

Derive an executable acceptance inventory from the verbatim goal — the ID'd observable outcomes the finished work must exhibit, each with a runnable evidence command where one can be derived — and write it to .rpiv/artifacts/acceptance/ in one non-interactive pass. Authored BEFORE any plan exists so the standard of completion cannot inherit the plan's scope: the plan later addresses or explicitly defers each item, the grade panel's completeness dimension anchors on the inventory, and validate executes the evidence commands against the finished tree. Dispatched by the ship and build presets between research and planning.

Surgically revises one artifact to clear the failing dimensions a grade panel flagged, re-emitting it in place so the gate re-judges the same channel.

Documents a project's architecture for AI assistants by writing compact architecture.md files into a .rpiv/guidance/ shadow tree alongside the source.

Documents a project's architecture for AI assistants by writing compact `CLAUDE.md` files inline next to the source they describe.

Conducts a top-down, layer-by-layer architecture review of a module and produces a phased polish plan in `.rpiv/artifacts/architecture-reviews/` that starts the polish pipeline.

One-pass replacement for `design` + `plan`. Decomposes a feature into vertical slices with developer micro-checkpoints and emits an implement-ready phased plan in a single run.

Regenerates the `[Unreleased]` section of every affected `CHANGELOG.md` from commits + uncommitted hunks, classified by Conventional Commit prefix. Monorepo-aware, idempotent.

Reads a diff, branch, or PR through Quality · Security · Dependencies lenses with parallel specialist agents and returns one cited report under `.rpiv/artifacts/reviews/`.

Reads the working tree, groups related changes into logical commits, and writes descriptive messages in the repo's style. Never amends, never adds AI attribution.

Compresses the current session's task, decisions, in-flight changes, and open questions into a single handoff document that a fresh session can pick up cold.

Decomposes a complex feature into vertical slices and produces a design artifact (architecture decisions, slice breakdown, file map) that the planning skills consume.

Runs the pipeline's one human design gate, presenting every per-slice design as a single consolidated summary the developer accepts or adjusts before synthesis.

Designs one vertical slice from a slice map in isolation, writing its architecture decisions, file map, key interfaces, and success criteria to `.rpiv/artifacts/designs/`.

Interviews you one question at a time to capture feature intent (Goals · Non-Goals · Functional Requirements · Acceptance Criteria · Decisions) into a Feature Requirements Document the research skill consumes.

Writes implement-ready code into one phase of a synthesized plan, emitting a per-phase elaboration to `.rpiv/artifacts/elaborations/` that a deterministic splice folds back into the plan.

Compares 2–4 candidate approaches across precedent-fit, integration risk, migration cost, verification cost, and novelty, then recommends one, ready to feed `design` or `blueprint`.

Forces a deliberate aesthetic *before* a line of frontend code. Scans the project's style system, asks only what isn't settled, and injects tailored design guidelines plus an anti-slop list.

Judges one artifact along one named quality dimension and writes a verdict JSON to `.rpiv/artifacts/verdicts/` as a single member of a gate's grading panel.

Executes an approved phased plan one phase at a time, applies changes, runs each phase's success criteria, and only advances when they pass.

One-shot move from inline `CLAUDE.md` files to the `.rpiv/guidance/` shadow tree, transforming cross-references along the way.

Sequences a design artifact into parallelized atomic phases with explicit success criteria, written to `.rpiv/artifacts/plans/`.

Read-only triage of an incoming GitHub PR — fetches the thread, weighs the diff against whatever standard the repo actually carries, and returns a disposition plus a security tier under `.rpiv/artifacts/triage/`.

Produce a single unsliced, consistently-phased implementation plan for a small, well-understood task and write it directly to .rpiv/artifacts/plans/ with status: ready — one non-interactive pass, no slice decomposition, no in-skill review (the workflow's grade and validate stages are the gates). Dispatched by the ship preset's plan stage; also usable standalone for a small task whose research is done or whose shape is obvious. Prefer blueprint for multi-component features needing slice-by-slice micro-checkpoints, and plan when turning an existing design artifact into phases.

Surgically repair a working tree whose validate run returned a failing verdict — re-run each failed verify-at-implement risk ruling's prescribed procedure and each structured blocker's failing command, apply the minimal localized code fix grounded in the validation report, then confirm it passes. Single-pass, no subagents, no self-review, no questions. Workflow-gated repair arm dispatched after a failing validate; use as a gate's repair stage.

Answers structured research questions about a codebase by formulating trace-quality questions, dispatching parallel analysis agents, and synthesizing a cited research document under `.rpiv/artifacts/research/`.

Reads a handoff document, re-verifies the working tree against it, and continues exactly where the previous session stopped.

Surgically updates an existing implementation plan after review feedback, mid-implementation discoveries, or scope changes, preserving structure rather than rewriting.

Decomposes a research-grounded feature into independent vertical slices and writes a machine-readable slice map to `.rpiv/artifacts/slices/` that a per-slice design fanout consumes.

Merges independent per-slice designs into one coherent phased plan in `.rpiv/artifacts/plans/`, reconciling overlaps and wiring integration seams as the fan-in barrier of the design fanout.

Independently re-runs each phase's success criteria against the working tree and emits a pass/fail validation report that catches half-finished phases the implement loop missed.