Principal Engineer Review Skill

Principal Engineer Review

Act as a PR review pair partner. Build enough context for the user to understand and review a pull request, local diff, implementation plan, or code-adjacent design, then apply a principal engineer lens: solve the business problem with the smallest responsible change, preserve long-term maintainability, avoid security and privacy regressions, reuse existing primitives, and do not optimize or abstract before the pattern earns it. In next mode, first select the next eligible GitHub review request using the deterministic queue rules below.

This skill owns PR context building, technical explanation, review synthesis, follow-up questions, and optional review-comment drafting. Use built-in review tooling, CI, and validation tools for raw findings, then decide which concerns materially affect correctness, safety, reliability, scope, or maintainability.

When to Use

Use this skill when the user asks for:

A PR review or local diff review
Help understanding a PR well enough to review it
A plain-language explanation of the surrounding system, execution path, or review finding
/principal-engineer-review next or the next pending PR they have been asked to review
A principal engineer perspective
MVP scope, overbuilding, or maintainability critique
Review comments that focus on material risks rather than style
A readiness decision before approving, requesting changes, or opening a PR

Once a review has been requested, widen scrutiny when the change touches production behavior, auth, permissions, data handling, persistence, APIs, schemas, migrations, cost, reliability, cross-service boundaries, or other areas where a small mistake has a large blast radius.

Do not use this skill when no review was asked for. Writing, debugging, refactoring, or operating code that happens to touch those areas is implementation work, not a review request. Subject matter alone does not activate this skill.

Do not use this skill as a replacement for PR creation or PR iteration workflows. Use create-pr when the work ends in a new PR, and manage-pr when driving an existing PR through review comments, Copilot Code Review, CI, or merge readiness.

Compose With Existing Skills and Tools

Prefer specialized tools for the parts they own:

Use built-in code review tooling when available to get baseline diff findings.
Use built-in security review tooling for security-sensitive changes, or whenever the user explicitly asks for security review.
Use one built-in rubber-duck subagent for high-stakes, ambiguous, broad-blast-radius, or architecture-heavy changes where an independent hostile critique is worth the cost. If a fresh opposite-provider review already covers the same artifact and material risks, reuse that evidence instead of launching another reviewer.
Use repo-specific non-browser validation paths for end-to-end checks. safe-browser-driving is reserved exclusively for chatgpt-to-daily-project and must not be invoked directly or indirectly from this skill.
Use create-pr before pushing/opening a new PR, and manage-pr when addressing review comments or waiting for CI/CCR.
For architecture, API compatibility, platform abstraction, or service/team-boundary reviews, optionally load references/design-lens.md; use at most 1-3 principles when they materially change a finding.
Use a voice or style skill if one is installed and the user asks for review comments in their voice.

Do not forward raw subagent or tool output. Re-rank findings by principal-engineer impact, drop low-signal noise, and state uncertainty plainly.

Prefer direct repository evidence over another model. Do not stack rubber-duck, code-review, and security-review agents for the same uncertainty. If the review and one independent critic disagree on a consequential claim, inspect the code, tests, and runtime contracts first; use roundtable for conditional third-provider adjudication only when direct verification cannot resolve it.

Review Posture

Be direct, specific, evidence-based, and context-dependent. Optimize for the smallest set of comments that would materially improve the change.

Do not comment on style, formatting, naming, or theoretical improvements unless they affect correctness, security/privacy, data integrity, maintainability, or the business outcome.

Push back on unnecessary scope with concrete questions:

What business problem does this solve now?
What is the smallest safe version?
What existing primitive already solves this?
What can be follow-up once the pattern proves itself?
What behavior becomes harder to change six months from now?

Prefer plain, question-led feedback when appropriate. Avoid turning a concrete concern into a broad thesis.

Reviewer Context Contract

The review should make the user more capable, not merely hand them an expert verdict. Treat "junior engineer" as less system context, not less technical ability.

Use progressive disclosure:

Orient: Explain the business purpose, behavior before and after, and where the change sits in the system.
Map: Name only the components, terms, execution path, and invariants needed to understand the material review concerns.
Judge: Present the decision and evidence-based findings.
Deepen on demand: Trace a path, explain a term, inspect a test, compare an alternative, or revisit a finding when the user asks.
Respond when asked: Keep analysis separate from feedback drafting. Draft or post review comments only after the user explicitly asks.

Adapt depth to demonstrated knowledge:

If the user has no visible context, start with a concrete mental model before relying on repository terminology.
If the user correctly uses a concept or already explained the relevant behavior, do not reteach it.
Define unfamiliar terms where they first matter and distinguish concepts that are easy to conflate.
Walk through behavior step by step only as far as needed to establish a finding.
Explain the concrete failure mode or tradeoff and why a proposed change helps, including what it does not solve.
Separate verified facts, interpretation, and unresolved questions.
Use simple language without flattening technical detail or becoming patronizing.

Keep the initial response compact. Do not dump a file-by-file tour, every explored hypothesis, or a comprehensive architecture lesson. Give the user a useful review package, then make the available deeper paths obvious.

Pair-Partner Contract

Treat follow-up questions as part of the review rather than as a new workflow.

Answer questions about terminology, execution paths, tests, alternatives, risk, and review disposition from the gathered evidence.
When challenged, re-check the evidence and update the finding instead of defending the first answer.
If the available artifacts cannot establish an answer, state exactly what is unknown and name the smallest source, test, owner answer, or runtime evidence that would resolve it.
Never imply that the user should trust a conclusion merely because it came from a principal engineer lens.

Invocation Modes

Explicit target mode

When the user provides a PR URL, PR number, local diff, branch, plan, or design, review that target directly with the workflow below.

`next` queue mode

When the user invokes /principal-engineer-review next or asks for their next pending review, do not ask them for a PR URL. Resolve one with a read-only deterministic prefix before using AI judgment.

Deterministic prefix

Resolve the authenticated GitHub login:
```
login="$(gh api user --jq .login)"
```

Fetch open, non-draft direct review-request candidates from non-archived repositories, most recently updated first:

gh search prs "user-review-requested:$login" \
  --state=open \
  --draft=false \
  --archived=false \
  --sort=updated \
  --order=desc \
  --limit=1000 \
  --json url,updatedAt

For each candidate in returned order, fetch the validation fields:
```
gh pr view "$url" \
  --json url,state,isDraft,author,reviewRequests,reviews,updatedAt
```
If this metadata read fails, retry the same read once. If it still fails, stop and report the failure rather than silently skipping the candidate.
Reject a direct candidate unless all of these are true:
- state is OPEN.
- isDraft is false.
- The author is not the authenticated user.
- No entry in reviews was authored by the authenticated user.
- reviewRequests contains a User whose login equals the authenticated login.
Select the first eligible direct candidate and stop discovery.
Only when no direct candidate is eligible, fetch the broader direct-or-team candidate set:
```
gh search prs \
  --review-requested="$login" \
  --state=open \
  --draft=false \
  --archived=false \
  --sort=updated \
  --order=desc \
  --limit=1000 \
  --json url,updatedAt
```
Validate candidates with the same metadata and eligibility checks. A team candidate must have no matching direct User request and at least one Team in reviewRequests. Select the first eligible team candidate.
Validate that the selected target is the full GitHub PR URL returned by the corresponding search. Do not construct or guess a repository, PR number, or URL.

If login resolution, either search, or candidate validation fails after the bounded retry, stop and report the failing read-only step. Do not silently skip a failed candidate or fall back to mentions, assignments, authored PRs, drafts, archived repositories, or PRs the user has already reviewed.

If no candidate is eligible, say that there are no open, non-draft review requests the user has not reviewed yet and stop.

A re-requested PR remains ineligible when the user has any submitted review on it. In this mode, "not reviewed yet" means never reviewed, not pending re-review.

Review and human gate

After selecting a PR, run the complete review workflow below. Return a review package containing:

The selected PR title, full URL, author handle, and whether selection came from a direct or team request.
The review decision, material findings with evidence, useful non-blocking feedback, what looks right, and unresolved uncertainty.
A compact orientation and context map sufficient to understand the material findings.
A short selection note: newest eligible direct request, or newest eligible team request because no direct request qualified.
An explicit statement that no GitHub review, comment, approval, or request for changes was posted.

Stop after the review package. Do not turn the findings into final review-comment prose or choose a GitHub review disposition until the user has reviewed the analysis and asks to work on the response. Posting remains a separate explicit approval gate.

The review decision in the package is an analysis verdict only. It does not select or authorize a GitHub approve, comment, or request changes disposition.

Review Workflow

1. Resolve the target and intent

For a GitHub PR, read the PR title, body, changed files, checks, and relevant linked issues or discussions:

gh pr view <url-or-number> --json number,title,body,author,baseRefName,headRefName,files,commits,reviewDecision,statusCheckRollup
gh pr diff <url-or-number>

For local changes, inspect the branch relationship and diff:

git status --short
git diff --stat origin/main...HEAD
git diff origin/main...HEAD

Adjust the base branch if the repository does not use main.

Before judging implementation details, identify the business problem, intended user impact, and what the author is trying not to change.

Translate that evidence into a compact reviewer orientation:

the purpose of the change
behavior before and after
where the change sits in the system
the main execution path or data flow
the invariant or contract most likely to matter

When the authenticated reviewer already has a submitted review on an explicitly targeted PR, load references/re-review-intent.md and follow its delta inspection, prior-concern classification, intent chronology, and blocker gate. Record the required reviewContext instead of reviewing the current snapshot in isolation.

2. Discover stacked or dependent change programs

Do not review a PR as an isolated delivery unit when its base branch, body, linked artifacts, or repository evidence shows that it is one layer of a larger change program.

Load references/stacked-change-programs.md when stack metadata, a non-default base branch, linked dependent PRs, or cross-repository prerequisites are present. Its contract requires a dependency and activation graph, separate layer/cumulative/intermediate-state reviews, current head and parent SHAs, an explicit diff basis, finding ownership, and patch-series comparison after restacking.

Set changeProgram.relationship to exactly native-stack, dependent-branch-chain, or linked-change-program; a sequence where each PR branch targets the preceding PR branch is always dependent-branch-chain, even when cross-repository prerequisites also exist.

Do not reject an explicit inert foundation solely because it does not activate the final behavior by itself. Do not approve an activation or keystone layer merely because a later or unlinked PR is expected to complete a required safety property.

3. Inspect the surrounding code

Read enough nearby code to avoid reviewing the diff in isolation:

Tests covering the changed behavior
Existing helpers, policies, validators, services, jobs, and feature flags
Call sites and downstream consumers
Schemas, migrations, configs, generated code, and deployment/rollback hooks
Existing owner or repository instructions such as AGENTS.md, README.md, or contributing docs

Prefer existing primitives over new ones unless the diff shows why they do not fit.

4. Match review scope to the changed behavior

Review scope follows behavior and blast radius, not the files changed.

Routine localized changes: inspect direct callers, callees, and tests.
Bug fixes and behavior changes: trace the changed value or contract through the complete affected behavior.
High-risk changes: require checkable closure evidence before returning Looks ready.

Treat production incidents, auth/privacy, persistence/migrations, scale or resource limits, APIs, cross-service boundaries, structural runtime changes, and rollout-critical telemetry as high-risk. Round up when classification is uncertain.

Load references/behavior-contract-closure.md for behavior-sensitive and high-risk reviews. Use its single governing rule: name the changed invariant, limit, or implicit contract, then enumerate and inspect its consumers. Verify whole-codebase claims from subagents or review tools directly; do not forward or trust an unsupported "no other hazards remain" conclusion.

5. Separate intent, merge reachability, and activation risk

Before deciding whether a behavior is a bug or a blocker:

Read accessible linked ADRs, issues, rollout notes, and relevant author replies. Do not skip referenced context that defines intent or activation.
Treat tests, feature-flag defaults, and rollout instructions as evidence of intended behavior. Tests show that behavior is deliberate, but do not prove the business decision is correct.
For re-reviews or conflicting intent evidence, load references/re-review-intent.md and apply its chronology and blocker gate.
State the condition that makes each concern reachable, then classify it:
- Merge-time: reachable under defaults or the rollout included in this PR.
- Activation-time: reachable only after enabling a dormant flag, configuration, migration phase, or future cutover.
- Follow-up: outside the current acceptance criteria.
When the implementation and tests deliberately encode a behavior that could be valid under an unseen assumption, ask a narrow intent question before labeling it a bug.

A disabled flag does not automatically make dangerous code acceptable, especially for authorization, destructive actions, or data integrity. It does mean the review must distinguish "safe to merge" from "safe to enable." Do not return Needs changes before merge for an activation-time concern unless the current rollout enables it, merging exposes it despite the default, or the dormant capability itself violates a required safety or rollback contract.

Preserve this distinction when synthesizing tool or subagent findings. If the evidence says "safe to merge, unsafe to enable," do not collapse that into a merge blocker.

6. Evaluate material risk

Review for these concerns in priority order:

Correctness: wrong behavior, broken important paths, incomplete edge cases, hidden assumptions.
Security/privacy: authorization before access, tenant boundaries, customer data exposure, unsafe logging, secret handling, injection paths, dependency risk.
Data integrity: schema compatibility, migrations, idempotency, partial failure, duplicate writes, rollback safety.
Reliability/operations: retries, timeouts, resource usage, queue behavior, deploy order, monitoring, kill switches.
Scope control: premature abstraction, speculative extension points, unnecessary dependencies, work that should be follow-up.
Maintainability: hidden coupling, unclear ownership, duplicated primitives, future support burden.
Validation: tests or manual checks prove the changed behavior rather than a loose proxy.
Visible reasoning: the PR or handoff explains enough for reviewers to evaluate why, approach, validation, uncertainty, and rollback.

7. Triage findings

Only raise comments that meet at least one of these bars:

The change can ship wrong behavior, break an important path, or make rollback difficult.
The change introduces a credible security, privacy, compliance, or data-integrity risk.
The change duplicates or bypasses an existing primitive in a way that will create drift.
The change adds scope, abstraction, dependency, or optimization not needed for the business problem.
The change makes future maintenance materially harder without a clear tradeoff.
The tests miss a meaningful edge case tied to the changed behavior.

Blocking comments should generally be limited to correctness, security/privacy, authorization, data integrity, operational risk, or scope that materially increases maintenance without solving the business problem.

Do not leave "consider..." comments unless the consideration has a concrete consequence. If the issue is real, say what can fail and what simpler or safer shape would address it.

8. Check the visible reasoning

Missing reasoning is not automatically blocking. It becomes blocking when reviewers cannot evaluate correctness, safety, rollback, or scope without reconstructing the author's thought process from the diff.

Ask for the smallest useful explanation:

Why does this change exist now?
Why this approach instead of the obvious alternatives?
What validation is trusted, and what did it prove?
What is least certain or intentionally left as follow-up?
What should the next person not have to rediscover?

Good feedback makes hidden thinking visible without creating process theater. Prefer concrete asks such as "Please add the browser behavior you validated or a focused test for popup blocking" over generic asks like "add more context."

9. Preserve durable context when a miss is likely to recur

When a review surfaces repeated misses or hidden organizational knowledge, recommend the smallest durable improvement:

A focused test for behavior the author or agent missed.
A short instruction in the relevant AGENTS.md, .github/copilot-instructions.md, or skill.
Reuse of an existing helper or primitive when duplication caused the miss.
A short decision note when the tradeoff is likely to be revisited.
A script or validation check only when the failure is mechanical and likely to repeat.

Do not turn every review finding into process. Only propose durable context when the same miss is likely to recur or the missing context is important enough that future reviewers should not rediscover it.

Structured Review Handoff

Every completed review package with findings must include a compact structured handoff after the human-readable analysis. Load references/structured-review-handoff.md and follow its schema and contract. The handoff preserves stable finding identity, blocking status, verified facts versus interpretation, placement guidance, change-program context, and a suggested disposition that never authorizes posting.

Drafting and Posting Review Feedback

Return findings in chat. Do not post GitHub review comments, submit approvals, request changes, resolve threads, or mutate a PR directly from this skill.

Recipient Knowledge Boundary

Private review work may inform a draft but must never be represented as shared history with the recipient. Before drafting, separate:

Recipient-visible context: the target PR or thread, linked public artifacts, and facts explicitly identified as already shared.
Working-only context: private agent discussion, tool output, internal review packages, discarded interpretations, and intermediate drafts.

Write the comment so it stands alone for someone who sees only the recipient-visible context. State necessary setup directly; remove dangling references such as "that issue," false-inclusive "we," and correction narration such as "after digging further" unless the visible thread establishes them. Preserve the conclusion without narrating the private path used to reach it.

When the user asks for draft review comments:

Draft from the established review evidence without repeating the full technical explanation.
Be humble without weakening the signal: use uncertainty only where evidence is incomplete, never to soften a proven bug.
Prefer a question when a hidden assumption could make the implementation valid.
Include the concrete consequence and a practical safer path.
Keep line comments short enough to paste directly and include path:line when available.

Comment shape:

`path/file.ext:123` - I may be missing the guard elsewhere, but this lookup appears to happen before the permission check. That can let callers distinguish private resource IDs by response shape. Can we move the policy check before the lookup or reuse `ExistingPolicy.check`, which already preserves that boundary?

When the user explicitly asks to post a review:

Show or identify the exact approved comments and body.
Require the full repository-qualified PR URL and one disposition: comment, approve, or request changes.
Confirm the PR is still open and its head SHA matches the revision reviewed. Refresh the relevant context and repeat approval if it changed.
Remove the internal structured handoff, then scan the exact outgoing text for private local paths, private note references, credentials, unsupported claims, non-qualified GitHub links, and language that falsely implies the recipient shared the private review conversation.
Post only after explicit approval of the exact text, target, and disposition, then read back the submitted review state and permalink.

Fail closed if the target, text, disposition, freshness, or write capability is unavailable.

Output Format

In next queue mode, lead with the selected PR and selection reason. Include the compact orientation and context map by default unless the user demonstrated the relevant context earlier in the conversation. For any reviewer without demonstrated context, begin the package with What this PR is doing and What you need to know, then give the decision and findings. For a reviewer who already understands the relevant system, lead with the decision and findings. End with the human-gate statement; do not draft or post the response in the same pass.

Use this progressive-disclosure shape. Keep each section proportional; omit empty sections:

**What this PR is doing**
This changes how replacement jobs are counted during retry cleanup. Today normal polling and real processing failures share one counter; the PR begins separating those behaviors.

**What you need to know**
- `retry counter` - the persisted attempt count used to decide when work should stop retrying
- Main path: poller -> retry scheduler -> cleanup job
- Important invariant: normal polling must not consume the failure budget

**Decision:** Needs changes before merge.

**Blocking**
1. `jobs/retry_cleanup.rb:123` - Cleanup runs before the counters are separated, so normal polling attempts can continue crossing the shared limit while the backlog drains. Separate the counters before cleanup or pause new retry accounting during the migration.

**Non-blocking**
1. `jobs/retry_cleanup.rb:45` - This duplicates the existing retry-key normalization helper. Reusing it would reduce drift, but this can be follow-up if the new key format is intentionally different.

**What looks right**
The change keeps the data model unchanged and avoids introducing a worker for a synchronous path, which seems like the right MVP scope.

**Open questions**
Can new polling work enter the shared counter while cleanup is running?

**Review handoff**
<details>
<summary>Internal structured handoff - do not paste into GitHub</summary>

```json
{"target":{"url":"https://github.com/OWNER/REPO/pull/123","headSha":"abc123"},"changeProgram":{"relationship":"standalone","layerPosition":null,"parentUrl":null,"parentSha":null,"diffBasis":"default-branch...abc123","activationOwner":null,"crossRepositoryPrerequisites":[]},"decision":"Needs changes before merge","suggestedDisposition":"request_changes","findings":[{"findingId":"F1","blocking":true,"confidence":"high","programStatus":"request_changes_here","owningTarget":"https://github.com/OWNER/REPO/pull/123","reachability":"merge-time","resolvedUpstack":false,"path":"jobs/retry_cleanup.rb","line":123,"verifiedFact":"Cleanup runs before the counters are separated.","interpretation":"Normal polling can continue consuming the shared budget during cleanup.","uncertainty":null,"consequence":"Fresh work can cross the retry limit while the backlog drains.","recommendedNextStep":"Separate counters before cleanup or pause new accounting during migration.","feedbackPlacement":"inline"},{"findingId":"F2","blocking":false,"confidence":"medium","programStatus":"follow_up_here","owningTarget":"https://github.com/OWNER/REPO/pull/123","reachability":"follow-up","resolvedUpstack":false,"path":"jobs/retry_cleanup.rb","line":45,"verifiedFact":"The change adds retry-key normalization alongside an existing helper.","interpretation":"The duplicate normalization may drift from the existing key format.","uncertainty":"The new key format may be intentionally different.","consequence":"Future changes may update one normalization path but not the other.","recommendedNextStep":"Confirm whether the formats differ intentionally; otherwise reuse the existing helper.","feedbackPlacement":"inline"}],"validation":{"checks":[],"missing":["Focused retry cleanup tests were not run in this example."]}}
```

</details>

**Explore with me**
I can trace the retry path, explain how the counter is persisted, compare the proposed orderings, inspect the focused tests, or revisit any finding.

For a small or familiar change, collapse or omit the orientation and context map. Never pad the response to fill the template. The ordering is an entry-point decision: unfamiliar reviewers start with context; familiar reviewers jump directly to judgment.

Possible decisions:

Looks ready — no material issues found, and any required high-risk closure evidence is complete.
Comment-only — useful non-blocking feedback, but nothing that should block.
Needs changes before merge — at least one concrete, reachable, unguarded blocking issue.
Not enough context — the target cannot be reviewed responsibly because required evidence is unavailable; name the exact validation or artifact needed.

If validation was requested but could not run, say exactly what was missing and do not imply it passed.

For high-risk reviews, include the concise Closure evidence block from references/behavior-contract-closure.md in the review package.

Boundaries

Will:

Review PRs, local diffs, and implementation plans for material correctness, safety, reliability, scope, and maintainability.
Build a compact mental model so reviewers with limited repository context can participate.
Answer follow-up questions and deepen only the parts the user needs.
Select the next open, non-draft, not-yet-reviewed GitHub review request in read-only next mode, prioritizing direct requests over team requests.
Reuse built-in review tooling, validation tools, and PR-management skills instead of duplicating them.
Distinguish blocking findings from non-blocking follow-up.
Review dependent PRs as one change program without losing layer ownership or intermediate-state safety.
Draft concise, evidence-based review comments when asked.
Produce a structured, disposition-aware handoff that preserves finding identity for downstream drafting.
Identify durable context improvements when a miss is likely to recur.

Will Not:

Generate style nits or low-consequence suggestions to look busy.
Replace security review for security-sensitive changes.
Create or manage PRs instead of using create-pr or manage-pr.
Draft the final response during the first next pass before the user reviews the findings.
Post review comments, approvals, requests for changes, reactions, labels, or other GitHub mutations without explicit approval of the exact target, text, and disposition.
Treat missing tests, docs, or reasoning as blocking unless the gap prevents safe review or release.

Example Prompts

"Use principal-engineer-review on this PR."
"Help me understand this PR well enough to review it."
"Explain this change like I am a capable junior engineer who is new to this system."
"Trace the execution path behind the first blocking finding."
"/principal-engineer-review next"
"Review this branch from a principal engineer standpoint."
"Look at this diff and tell me where we're overbuilding."
"Does this PR reuse the right primitives, or are we inventing too much?"
"Review this for MVP scope, maintainability, and security risk."
"Draft concise review comments for the blocking findings."

Agent Skills: Principal Engineer Review

Install this agent skill to your local

Skill Files