Requesting Code Review

What the source does

• FilesystemNone observedNo reads or writes in the source
• NetworkNone observedNo outbound calls in the source
• ShellNone observedNo commands run in the source
• DependenciesPinnedNothing floats
• SecretsNone foundNo keys in source

Five audit layers

Gates applied: no behavioural pass.

Audit 0.4.1 · source sha 177240a262fe · 18 Oct 2026Report an issue or request a re-scan

• PublisherGanyuanRan GitHub userOwner of the repository this skill is read from
• Source folderGanyuanRan/Aegis/skills/requesting-code-reviewThe exact folder we audited
• LicenceMITAs the repository states it
• Commit pinned for this verdict177240a262feA new audit runs when the source changes
• Repository statusNot archivedPushed today
• Sandboxed runNot runSkills are read, not executed; layer L4 is skipped

Its description: Use when requesting independent code review, after implementation slices, before merging high-risk work, or when verification exposes evidence, baseline, architecture, compatibility, or retirement uncertainty.

---
name: requesting-code-review
description: "Use when requesting independent code review, after implementation slices, before merging high-risk work, or when verification exposes evidence, baseline, architecture, compatibility, or retirement uncertainty."
---

# Requesting Code Review

Dispatch a reviewer subagent using the canonical `code-reviewer.md` template to
catch issues before they cascade. The reviewer gets precisely crafted context
for evaluation — never your session's history. This keeps the reviewer focused
on the work product, not your thought process, and preserves your own context
for continued work.

This skill is the canonical review-request workflow for method-pack implementation work. Use it to request review only after you have enough evidence, enough context, and a clear authority boundary for what the reviewer is being asked to assess.

**Core principle:** Review early, review often.

**Findings First:** Reviews lead with concrete findings before summary. Use
bugs first, risk first, tests first. Strengths and general assessment are still
useful, but they must not bury correctness, evidence, architecture, or
retirement problems.

Review readiness is not merge approval. A review can reduce uncertainty and
recommend readiness, but it does not replace `verification-before-completion`
and does not grant completion authority.

## When to Request Review

**Mandatory:**
- After each task in subagent-driven development
- After completing major feature
- Before merge to main

**Optional but valuable:**
- When stuck (fresh perspective)
- Before refactoring (baseline check)
- After fixing complex bug

## Required Outputs

Before you leave this workflow, you must be able to state:

1. **What exact scope is being reviewed**
2. **What plan, requirement, or contract defines success**
3. **What Product / Requirement Baseline defines accepted behavior and non-goals**
4. **What Architecture / Runtime Boundary Baseline defines the expected architecture state**
5. **What fresh evidence already exists**
6. **What compatibility boundary must still hold**
7. **What old owner / fallback / patch stays, shrinks, or retires**
8. **What the reviewer must specifically validate**
9. **Whether the reviewer is providing advisory review only, or also any higher-level merge recommendation**
10. **Aegis Visibility**: why findings-first ordering, evidence sufficiency,
    baseline alignment, compatibility, or retirement risk matters for this
    review request
11. **Semantic context scope**: which relevant canonical terms, deprecated
    aliases, or public naming boundaries the review must preserve

Review in this method pack is advisory and evidence-oriented. It is not authoritative completion by itself.

## How to Request

**1. Gather minimum review inputs:**

- What was implemented
- What requirement / plan / spec / ADR it should match
- What baseline / current authority docs the diff must align with, including
  requirements/product alignment and architecture/current-authority alignment
- What evidence already exists (tests, commands, logs, screenshots, diff summary)
- What compatibility boundary or risk deserves reviewer attention
- Whether there is any old path, fallback, duplicate owner, or temporary patch that should retire
- Whether the diff contains durable architecture decisions that need ADR
  Auto Backfill or baseline sync findings
- Whether `recording-architecture-decisions` was used, or should be used, when
  an ADR action or baseline sync closure is in scope
- Relevant active `CONTEXT.md` language when public/domain naming is in scope;
  passive reading does not load active modeling

If you cannot answer these, stop and gather them before dispatching review.

**2. Define the Git review scope:**
```bash
# Before the coordinator's task commit
REVIEW_SCOPE=working-tree
BASE_SHA=$(git rev-parse HEAD)

# Or for already committed work
REVIEW_SCOPE=committed-range
BASE_SHA=<known-start>
HEAD_SHA=$(git rev-parse HEAD)
```

For working-tree review, identify task-owned untracked paths explicitly. Do not
stage merely to make them visible to a reviewer.

**3. Dispatch reviewer subagent:**

Use the Task tool with a general-purpose reviewer subagent. Fill the canonical
template at `requesting-code-review/code-reviewer.md`; do not rely on a
separate named agent prompt.

**Placeholders:**
- `{WHAT_WAS_IMPLEMENTED}` - What you just built
- `{PLAN_OR_REQUIREMENTS}` - What it should do
- `{EVIDENCE}` - Fresh tests, commands, logs, or verification already available
- `{COMPATIBILITY_BOUNDARY}` - What existing behavior or interfaces must not break
- `{RETIREMENT_NOTES}` - Old owner / fallback / patch / duplicate branch and expected disposition
- `{REVIEW_SCOPE}` - `working-tree` or `committed-range`
- `{BASE_SHA}` - Starting commit
- `{HEAD_SHA}` - Ending commit, or `WORKTREE`
- `{DESCRIPTION}` - Brief summary

**4. Act on feedback:**
- Fix Critical issues immediately
- Fix Important issues before proceeding
- Note Minor issues for later
- Push back if reviewer is wrong (with reasoning)
- If feedback reveals evidence gaps, run the missing verification instead of arguing from confidence
- If feedback reveals Design Defect / Implementation Drift, stale logic, or a
  legacy alias such as architecture drift, decide explicitly whether to repair
  now, correct the baseline, or record retirement conditions

## Example

```
[Just completed Task 2: Add verification function]

You: Let me request code review before proceeding.

BASE_SHA=$(git log --oneline | grep "Task 1" | head -1 | awk '{print $1}')
HEAD_SHA=$(git rev-parse HEAD)

[Dispatch reviewer subagent using requesting-code-review/code-reviewer.md]
  WHAT_WAS_IMPLEMENTED: Verification and repair functions for conversation index
  PLAN_OR_REQUIREMENTS: Task 2 from docs/aegis/plans/deployment-plan.md
  EVIDENCE: pytest tests/index/test_verify.py -v -> 12 passed
  COMPATIBILITY_BOUNDARY: Existing index format and CLI flags must remain stable
  RETIREMENT_NOTES:

Excerpt, first 6,000 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.

git clone https://github.com/GanyuanRan/Aegis
git -C Aegis checkout 177240a262fe

Works in

1. 2026-10-18
   ✓SAFE B 89 / 100

   first audit · source 177240a262fe

Questions about Requesting Code Review

• github.com/GanyuanRan/Aegis/tree/main/skills/requesting-code-rev — the audited source at commit 177240a262fe and every finding aboveObserved · 18 Oct 2026

Spotted something wrong? Report a correction · Methodology