Code Review

YOUR ARGUMENTS: $ARGUMENTS

DO NOT ask the user for arguments. They are provided above. Parse them NOW and proceed with the review.

The argument is the path to the phase file to review (e.g., plans/voice-assistant/phase-01-database-schema.md ).

Recent Git Activity

Recent commits (helps identify which files were modified for this phase):

!git log --oneline -10 2>/dev/null || echo "(not a git repository)"

Recently changed files:

!git diff --name-only HEAD~5 2>/dev/null || echo "(no recent changes)"

Why This Review Exists

The user depends on this review to catch issues before they reach production. Self-review misses problems because the implementer has blind spots about their own code.

What skipping or rushing this review costs the user:

Missed Check Consequence

Step verification Features incomplete, user discovers gaps in production

Security issues (RLS, credentials) Data leakage between accounts, security incidents

Project pattern compliance Inconsistent codebase, harder to maintain

Codebase pattern deviation Code works differently from every other feature, confusing to maintain

Persistent review record No audit trail, same mistakes repeated across future phases

This review creates accountability. Specific file:line references and concrete fixes give the user actionable feedback — not vague "looks good" responses that hide problems.

Codebase-Grounded Review

This review is grounded in the actual codebase, not just a static checklist. Before flagging pattern violations, you read a reference implementation to confirm what the correct pattern looks like. This prevents:

• Flagging things that are actually correct in this codebase

• Missing violations because the checklist is stale

• Giving generic advice instead of specific "line X should match how it's done in file Y"

Output Location

Code/implementation reviews go in the reviews/code/ subfolder:

• Phase file: plans/feature-name/phase-01-slug.md

• Review file: plans/feature-name/reviews/code/phase-01.md

Examples:

• plans/250202-voice-assistant/reviews/code/phase-01.md

• plans/250202-voice-assistant/reviews/code/phase-12.md

Create the reviews/code/ directory if it doesn't exist.

Note: Planning/template reviews go in reviews/planning/ instead — see /review-plan skill.

Delegation & Batching

For instructions on spawning multiple code review agents in batches, see delegation.md.

Task Tracking

Tasks survive context compacts — skipping this check causes lost progress and repeated work.

Before starting work, run TaskList to check if tasks already exist from a previous session or before a compact. If tasks exist:

• Read existing tasks with TaskGet for each task ID

• Find the first task with status pending or in_progress

• Resume from that task — do NOT recreate the task list

If no tasks exist, create them after Step 2 (identifying files to review):

Example task list:

Task 1: Read phase document and extract requirements Task 2: Identify files to review Task 3: Find reference implementations Task 4: Run completeness check Task 5: Run code quality & codebase compliance check Task 6: Write review file using template Task 7: Auto-fix Critical and High issues Task 8: Return summary with next steps

Mark each task in_progress when starting and completed when done.

Workflow

Step 1: Read the Phase Document

Read the phase file at the path provided in the arguments above. Extract:

• All Implementation Steps (Step 0 through Step N)

• All Verifiable Acceptance Criteria

• All Functional and Technical Requirements

Step 2: Identify Files to Review

The user should have provided a file list when invoking. If not, ask which files were modified in this phase. You cannot use git commands.

Step 3: Find Reference Implementations

Before reviewing code quality, read at least one reference file from the codebase. This grounds your review in actual patterns, not memory. Without this step, you risk flagging correct code as violations or missing actual deviations.

Classify the files under review and find a reference for each type:

File Type How to Find Reference

Server actions Glob: app/home/[account]/**/server-actions.ts — read one

Service files Glob: app/home/[account]/**/service.ts — read one

Zod schemas Glob: app/home/[account]/**/*.schema.ts — read one

SQL migrations Glob: supabase/migrations/*.sql — read a recent one

React components Glob: app/home/[account]/**/_components/*.tsx — read one

Page files Glob: app/home/[account]/**/page.tsx — read one

Test files Glob: tests/**/*.test.ts — read one

Read the reference file. This is your ground truth for:

• Function signatures (e.g., Server Action auth pattern)

• Import paths and sources

• Naming conventions

• File organization

• Error handling patterns

Complete this step before Step 5. Flagging pattern violations without first confirming the correct pattern from a real file leads to false positives that waste the user's time.

Step 4: Completeness Check

Verify every section in the phase document was implemented. See checklist.md for detailed criteria.

Step 5: Code Quality & Codebase Compliance Check

Review the files against project patterns, security requirements, AND the reference implementations from Step 3. See checklist.md for detailed criteria.

For each file under review:

• Compare its patterns against the reference from Step 3

• Check against the codebase compliance checklist in checklist.md

• Flag deviations with severity and specific file:line references

When flagging an issue, cite the reference: "Line 42 uses async (data) => but reference file claude-ai-server-actions.ts:65 shows async (data, user) => is required when auth: true ."

For React/Next.js Code: Load Performance Guidelines

If reviewing React components, Next.js pages, or frontend code, invoke:

/vercel-react-best-practices

This loads 57 performance rules. Check the code against CRITICAL and HIGH priority rules:

CRITICAL - Eliminating Waterfalls:

• No sequential awaits for independent operations (use Promise.all)

• Suspense boundaries for streaming content

• Early promise initiation in API routes

CRITICAL - Bundle Optimization:

• No barrel file imports (import directly from source)

• Heavy components use next/dynamic

• Third-party scripts deferred after hydration

HIGH - Server-Side Performance:

• React.cache() for per-request deduplication

• Minimal data serialization to client components

• Parallel data fetching in server components

MEDIUM - Re-render Optimization:

• Derived state computed during render, not useEffect

• Memoization for expensive computations

• useTransition for non-urgent updates

Flag violations in the appropriate priority section of the review.

Step 6: Read Output Template and Write Review File

Read the output template BEFORE writing the review.

Reviews written without reading the template first produce inconsistent formats that the user cannot compare across phases. Read references/CODE-REVIEW-TEMPLATE.md and follow the exact format specified.

The template defines the exact sections, table columns, and verdict format. Inventing custom formats, adding extra sections like "Positive Observations" or "Technical Excellence", or using emoji checkmarks breaks the user's ability to track review status consistently across phases.

Write to: {plan-folder}/reviews/code/phase-{NN}.md

Step 6b: Validate Review Format

After writing the review file, run the validation script to catch structural issues:

python ${CLAUDE_SKILL_DIR}/scripts/validate_review.py {review-file-path}

If validation fails, fix the reported issues in the review file before proceeding. The script checks for missing sections, incorrect table formats, and forbidden patterns (like "Positive Observations" sections that aren't in the template).

Step 7: Auto-Fix Critical and High Issues

If no Critical/High issues were found, skip to Step 8.

Default: FIX IT. Most review issues are straightforward pattern corrections. Auto-fix is the expected outcome, not the exception. A review that identifies problems but fixes nothing is only half the job.

Fix Critical and High issues directly in the source files:

For each Critical/High issue: a. Read the source file at the file:line cited in the review b. Read the reference file that shows the correct pattern c. Apply the fix using Edit (for targeted changes) or Write (for new files)

Examples of fixes to make (never defer these):

• Wrong function signatures — fix to match the reference

• Missing 'use client' or 'use server' directives

• Wrong import paths or import ordering

• Missing error handling where the reference shows a clear pattern

• Missing server-only imports in server-side files

• Wrong TypeScript types (e.g., any where a proper type exists)

• Security issues: missing RLS checks, exposed credentials, missing auth

• Naming/convention violations where the reference shows the correct pattern

The ONLY reasons to defer to the main agent (use sparingly):

• The fix would change the feature's business logic or user-facing behavior

• The fix contradicts the phase's Decision Log or architectural approach

• You genuinely cannot determine the correct fix even after reading references

False positives — skip cleanly, don't argue: If a finding doesn't clearly apply to this codebase's patterns, or the reference file confirms the code is actually correct, mark it "Not applicable — matches reference at [file:line]" and move on. Do not include borderline findings in the issues tables.

After fixing, re-read the file to verify the fix is correct and doesn't introduce new issues.

Update the review file:

• Append "(Auto-fixed)" to fixed items in the Issues tables

• Fill in the "Fixes Applied" section (see template)

• Update the Verdict to reflect only remaining unfixed issues

Step 8: Return Summary with Next Steps

After writing the review file, return:

• Review file location

• Verdict (Ready/Not Ready) — based on remaining unfixed issues only

• Count of issues (total, auto-fixed, deferred)

• Reference files used

• Auto-fixed (count and brief list of what was fixed)

• Deferred to main agent (issues not auto-fixed and why)

• Next Steps for Medium/Low — present as improvement opportunities

Improvement mindset: When listing Medium/Low issues, frame them as concrete improvements worth doing now — not optional niceties. Phases are rarely revisited after completion, so "fix later" effectively means "never." The user prefers investing in quality now over speed.

Action directive for main agent: If there are deferred items or Medium/Low suggestions, end your summary with:

ACTION REQUIRED: [N] deferred items and [M] improvement suggestions need main agent attention. Please review the items above and fix or discuss with the user before proceeding.

Troubleshooting

Review produces false positives (flagging correct code)

Cause: The review skipped Step 3 (reading reference implementations) and flagged code based on assumptions rather than actual codebase patterns.

Fix: Always read at least one reference file of each type before flagging issues. If the codebase uses a pattern that differs from generic best practices, the codebase wins.

Review is superficial ("looks good, no issues found")

Cause: The reviewer didn't read individual files at specific line numbers, relying on a surface-level scan instead of deep inspection.

Fix: For each file under review, read the full file and compare line-by-line against both the phase requirements and the reference implementation. Check every import path, function signature, and error handling pattern.

Auto-fix introduces new issues

Cause: The fix was applied without re-reading the file to verify correctness, or the fix didn't account for surrounding context.

Fix: After every Edit, re-read the modified file to verify the fix is correct. Check that imports still resolve and that the change doesn't break adjacent code.

Review format is inconsistent across phases

Cause: The reviewer didn't read references/CODE-REVIEW-TEMPLATE.md before writing (Step 6). Custom formats break the user's ability to track review status.

Fix: Always read the template first and follow its exact structure. Do not add custom sections or change the table format.

Resuming After Context Compact

If you notice context was compacted or you're unsure of current progress:

• Run TaskList to see all tasks and their status

• Find the in_progress task — that's where you were

• Run TaskGet {id} on that task to read full details

• Continue from that task — don't restart from the beginning

Tasks persist across compacts. The task list is your source of truth for progress, not your memory.

Pattern for every work session:

TaskList → find in_progress or first pending → TaskGet → continue work → TaskUpdate (completed) → next task

Constraints

• Write review files within the plan folder

• When auto-fixing, you may also edit source files cited in the review

• Read the phase file FIRST before reviewing code

• Read at least one reference implementation before flagging pattern violations

• Cite references when flagging codebase pattern issues (e.g., "reference: claude-ai-server-actions.ts:65")

• Be specific with file paths and line numbers

• Critical and High issues block phase completion (unless auto-fixed)

• Auto-fix: Default is to fix. Only defer for genuine business logic changes or ADR contradictions

• Auto-fix: "Needs verification" is not a valid excuse — use Glob/Grep/Read to verify, then fix

The user configured this review to be thorough because vague feedback ("looks good", "some issues") doesn't help fix problems. Specific file:line references, comparison to known-good reference code, and concrete fixes are what the user needs to take action.