Skills Reference

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/`.

Triage a GitHub pull request before committing review effort — fetch the PR thread (description, review comments, linked issues, CI status), assess the diff against whatever architecture/standards the target repo actually carries, and emit a triage disposition (Review · Request changes · Hold · Decline) with security tier and convention drift. Use when the user wants a PR sized up, asks 'should I review/merge this PR', or wants a recommended next step on an incoming PR. Produces triage documents in .rpiv/artifacts/triage/. Read-only — never checks out or mutates the working tree. Stack-agnostic: works in any language or framework, with or without architecture docs.

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.