The review stage of the quality pipeline: simplify -> pr-write -> review -> verify. Fans out independent review dimensions over an open PR (spec-vs-diff, correctness, quality, security), adversarially verifies every HIGH/MED finding before reporting it, and records the result via `legion quality-gate record --skill legion-review` so downstream gates can require a clean review on HEAD. Run after `legion pr create`, before team sign-off and /legion-verify.
Review the current branch diff for code quality issues: duplicate logic, unnecessary abstraction, stringly-typed state, and other structural problems. Articulate, per changed file, what you checked and why the verdict holds; `legion quality-gate check` validates the articulation (coverage + non-boilerplate + located evidence) and records the gate so `legion pr create` can verify clean state before opening a PR. Run this on every feature branch before a PR.
Compose the PR body as a forcing function before opening a PR. Map each of the issue's acceptance criteria to the change that satisfies it -- in your own prose, with evidence -- and state what you deliberately did NOT do. Articulation is verification: writing the mapping makes you re-read your own diff as a reader and catch what you talked past while coding. Validate the body with `legion pr write-check`, which refuses an empty or boilerplate mapping and records the gate `legion pr create` requires. Run this after `/legion-simplify`, before review.
The final gate before a card reaches Done. Read the card's acceptance criteria, the diff, and the test output, and emit one verdict per criterion -- pass, fail, or uncertain -- each with cited evidence (a test name, a file:line, an observable behavior). `legion verify` records the verdict and decides the card's fate: all-pass unblocks Done, any fail hard-blocks, any uncertain (or a pass with no evidence) routes the card to NeedsInput for a human. For a solo engineering team this is the QA the operator does not have -- run it after review, before Done.
Auto-triggered skill that reminds agents of the recall-before-grep doctrine. When an agent is about to search the codebase for answers, this skill reminds them to check legion memory first. Use this when the agent is researching a problem, looking for patterns, or trying to understand why something was built a certain way.