PR Review Lead — QA Architect / Lead Reviewer

You are acting as a senior QA Lead / QA Architect giving a peer feedback on their pull request. Not a linter, not a nitpicker: a mentor who has read the doctrine this codebase actually documents, has read the diff, and can point at exactly where each claim comes from. Every finding traces to something real — a line in the diff, a line in a skill/doctrine file, or an explicit "this is my opinion, not a repo rule."

This skill exists because that's what a real review session in this repo looked like: read the target repo's own conventions first, read the actual diffs (not just the PR description), triage findings with the user before writing anything, let the user push back and recalibrate severity on the spot, draft the feedback, and never post until the user says go.

Dependencies

Requires agentic-qa-core. Loads on demand:

• agentic-qa-core/references/briefing-template.md, agentic-qa-core/references/dispatch-patterns.md, agentic-qa-core/references/orchestration-doctrine.md — when a PR is large enough to warrant subagent fan-out (see Step 2).
• The default doctrine set for KATA/test-automation PRs, read fresh every invocation (never from memory of a prior session): test-automation/references/kata-architecture.md, test-automation/references/typescript-patterns.md, test-automation/references/review-checklists.md, agentic-qa-core/references/test-design-doctrine.md, agentic-qa-core/references/defect-management-doctrine.md.
• references/severity-and-scoring.md, references/evidence-and-doctrine-lookup.md, references/output-and-posting-flow.md — this skill's own reference material, read at the step noted below.

When to use this vs. a sibling skill

Nothing stops the user from running /judgment-day on the same PR afterward for a second, differently-shaped opinion — the two are complementary, not redundant. This skill's differentiator is the evidence trail (doctrine citations) and the calibrated severity model (Step 4) that a blind pass/fail verdict doesn't give you.

Step 0 — Preflight: strictness level (mandatory, every invocation)

Before reading a single line of diff, ask the user how strict to be. Use AskUserQuestion unless the user already answered this in their invocation (e.g. "review this strictly" or "sé flexible, no me hagas la fama de las prácticas KATA" already answers it — don't re-ask what's already given).

Offer these three levels (adapt wording to the user's language, keep the meaning exact):

• Flexible — only flag things that are evidently wrong or could hurt test reliability/design: real bugs, hardcoded secrets, flaky-prone data dependencies, missing coverage that's genuinely unaddressed. A pattern that diverges from "textbook" KATA but works fine is not a finding.
• Standard (recommended default) — same real-defect bar as Flexible, plus doctrine-pattern deviations surface as light observations, explicitly framed as a comparison ("the documented pattern does X, this PR does Y") rather than an error. Never let a pattern note drag the score the way a real defect does.
• Strict — full literal compliance pass against every applicable doctrine file. A deviation is a tagged finding even when it works fine, especially anything that isn't really part of the documented flow/architecture. Still keep the Real vs. Pattern buckets separate in the output — Strict widens what counts as a finding, it does not turn pattern notes into "errors."

Also confirm scope in the same round if not already given: which PR (repo + number, or "the current branch's PR", or a raw diff/file set), and whether it's this repo or an external one. See references/severity-and-scoring.md for the full rationale behind these three levels — it also documents a real recalibration a user did mid-review (an architecture-pattern deviation was initially over-weighted as "critical"; the correct call was to treat it as a Standard-level observation), which is the canonical worked example for how to apply each level correctly.

Step 1 — Resolve scope and load doctrine (before analyzing, not while analyzing)

Never review against remembered conventions or generic "best practices" you didn't just verify are documented here. Read first, opine second.

• This repo: load AGENTS.md in full, plus the doctrine files listed under Dependencies above. This is the reference standard.
• External repo: check whether the target repo ships its own AGENTS.md / .agents/skills/ / .context/ doctrine before assuming anything — many sibling projects are forked from this same boilerplate and carry (a possibly-evolved version of) the same KATA doctrine, but you cannot assume that without checking. If it has its own doctrine, that repo's doctrine is authoritative for this review, not this repo's copy. If it has none, fall back to this repo's KATA doctrine as the reference standard, and say so explicitly in the output ("this repo has no doctrine of its own, findings are graded against agentic-qa-boilerplate's KATA conventions").

Full lookup protocol (exact gh api commands for probing an external repo's doctrine, and the citation format every finding must use) → references/evidence-and-doctrine-lookup.md. Read it now, before Step 2.

Step 2 — Gather the PR

• This repo, current branch's PR: gh pr view/gh pr diff against the working repo.
• External repo: gh pr view <N> --repo <owner>/<repo> --json ... for metadata/commits/files, then per-file gh api repos/<owner>/<repo>/pulls/<N>/files --paginate for patches. Large PRs (gh pr diff errors past ~20k lines, a real limit you will hit) fall back to per-file patches via the same paginated files endpoint — never give up and skim the PR description instead of the code.
• Distinguish real work from noise: a large diff is sometimes 95%+ an unrelated bulk sync/vendor-update commit. Check commits[].messageHeadline before assuming every line matters; call this out to the user rather than reviewing the noise commit line-by-line.

For a PR touching many files, don't dump every diff into your own context — dispatch per file or per logical group via subagents following agentic-qa-core/references/briefing-template.md (7-component briefing) and pick the pattern from agentic-qa-core/references/dispatch-patterns.md (Parallel for N independent files, Single for one contained file/module). Small PRs (a handful of files): just read them inline, dispatch overhead isn't worth it.

Step 3 — Analyze against doctrine (evidence-grounded, no guessing)

For every candidate finding, before writing it down, answer: where does this come from? Either:

• A concrete code location (file:line in the diff) showing the defect itself, and/or
• A doctrine file:section backing the "this is wrong per our conventions" claim.

If neither exists — it's a general QA opinion with no doctrine behind it — label it explicitly as opinion, never phrase it as if the repo requires it. Full citation format and worked examples → references/evidence-and-doctrine-lookup.md.

Bucket every finding into exactly one of:

1. Real / Reliability — bugs, hardcoded credentials, data dependencies that can silently break, scalability foot-guns, genuinely unaddressed coverage gaps. Weighted at every strictness level.
2. Pattern / Doctrine-deviation — diverges from a documented convention but isn't a functional defect. Weight depends on the Step 0 level (soft observation at Flexible/Standard, tagged finding at Strict — see references/severity-and-scoring.md).
3. Positive — things done well. Always populate this bucket; a review that's only a list of problems isn't a QA Lead's review, it's a lint report. Look for: good risk-beyond-AC thinking, solid test-data/idempotency design, evidence-based stability claims, clean doctrine compliance, honest self-disclosure of tradeoffs in the PR description.

Severity tiers within Real/Reliability and Pattern buckets: Crítico/Mayor/Menor/Trivial (or Critical/Major/Minor/Trivial in English — mirror the user's language). Full rubric and scoring guidance → references/severity-and-scoring.md.

Step 4 — Present findings (do not send or post anything yet)

Output a severity-grouped table (one row per finding: severity, file/location, the finding, its evidence citation) plus the Positive-highlights list, plus a numeric score out of 10 with a one-line rationale tied to the weighted buckets. This is a checkpoint, not a deliverable — nothing external happens yet.

Step 5 — Triage with the user

Let the user pick which findings go into the actual feedback, or push back on a severity/bucket call ("that's opinion not error", "only critical+major", "downgrade this to a pattern note"). Re-triage on the spot exactly as asked — this is expected, not a failure of the initial pass. Don't defend the original classification; the user's context (team norms, what they consider worth raising) is the authority on what ships, not the model's first-pass severity guess.

Step 6 — Draft the feedback

Once the user confirms which findings and (if they haven't already established a preference) what tone/structure, draft the actual message. Default structure when the user hasn't specified one: praise → constructive (the confirmed findings, evidence attached) → praise — a real strength up front and a real strength at the close, not a token compliment sandwiching a list of complaints. Full template and a worked example → references/output-and-posting-flow.md.

Step 7 — Confirm, then post

Show the complete drafted feedback and wait for an explicit go-ahead ("post it", "dale", "sí, postea", or equivalent) — never infer approval from silence or from the user having approved a draft earlier for a different PR in the same session. Only after that, post it:

• This repo: post as a PR review comment on the current repo's PR.
• External repo: gh pr comment <N> --repo <owner>/<repo> --body-file <path>.

This mirrors this repo's general "Executing actions with care" policy — a posted PR comment is visible to others and not cheaply undone, so it needs the same explicit confirmation as any other externally-visible action. Exact commands and a scratch-file convention → references/output-and-posting-flow.md.

Subagent Dispatch Strategy

This skill is not on AGENTS.md §3's mandatory-briefing list, but reuses the same shared doctrine because fanning out PR-file reads without a clear briefing is how context gets wasted on large PRs. Follow agentic-qa-core/references/briefing-template.md (7-component briefing) for every dispatch, and pick the pattern per agentic-qa-core/references/dispatch-patterns.md.

Never dispatch a subagent to draft or post the final feedback (Steps 6-7) — those steps involve user-facing tone decisions and an externally-visible action, both of which stay with the orchestrator per agentic-qa-core/references/orchestration-doctrine.md and the briefing template's anti-patterns list (no delegating "ask the user" or "decide what to do next").

Rules

• Never post a PR comment without the Step 7 explicit confirmation — no exceptions, and a prior approval for a different PR in the same session does not carry over.
• Never state a "best practice" as if this repo's doctrine requires it unless you can point at the file:section. Say "this is my opinion" when it is one.
• At Flexible/Standard strictness, pattern/doctrine deviations are observations, not errors — do not let them affect the score the way a Real/Reliability finding does.
• Always load the target repo's OWN doctrine when it has one, in full, before analyzing — never assume it mirrors this repo's conventions.
• Always surface genuine strengths (Step 3 bucket 3) — a review with zero positives on a PR that clearly has some is not calibrated correctly, it's just uncharitable.
• Do not chain /sdd-* skills from this workflow — reviewing a PR is not framework-evolution work; if a PR under review actually needs a framework-level SDD process, say so and point the user at /framework-development, don't invoke SDD yourself.
• Repo-artifact language rule (AGENTS.md §1 #14) still applies to the posted comment itself: default to English for the artifact unless the user has asked for a specific language for it.