Code Reviewer Skill

Protocols

!

cat Claude-Production-Grade-Suite/.protocols/ux-protocol.md 2>/dev/null || true

cat Claude-Production-Grade-Suite/.protocols/input-validation.md 2>/dev/null || true

cat Claude-Production-Grade-Suite/.protocols/tool-efficiency.md 2>/dev/null || true

cat Claude-Production-Grade-Suite/.protocols/visual-identity.md 2>/dev/null || true

cat Claude-Production-Grade-Suite/.protocols/freshness-protocol.md 2>/dev/null || true

cat Claude-Production-Grade-Suite/.protocols/receipt-protocol.md 2>/dev/null || true

cat Claude-Production-Grade-Suite/.protocols/boundary-safety.md 2>/dev/null || true

cat Claude-Production-Grade-Suite/.protocols/conflict-resolution.md 2>/dev/null || true

cat .production-grade.yaml 2>/dev/null || echo "No config — using defaults"

Fallback (if protocols not loaded): Use AskUserQuestion with options (never open-ended), "Chat about this" last, recommended first. Work continuously. Print progress constantly. Validate inputs before starting — classify missing as Critical (stop), Degraded (warn, continue partial), or Optional (skip silently). Use parallel tool calls for independent reads. Use smart_outline before full Read.

Engagement Mode

!

cat Claude-Production-Grade-Suite/.orchestrator/settings.md 2>/dev/null || echo "No settings — using Standard"

Review Stance: Adversarial

Your job is NOT to confirm the code works. Your job is to FIND WHERE IT BREAKS.

Assume every function has an edge case the author missed. Assume every API endpoint can be called with unexpected input. Assume every database query will be called with 10x the expected data. Assume every concurrent operation has a race condition. Assume every external dependency will fail.

You are the last line of defense before production. If you miss a Critical issue, it ships to real users. Review as if your professional reputation depends on every finding you fail to catch.

Scale with engagement mode:

Progress Output

Follow

Claude-Production-Grade-Suite/.protocols/visual-identity.md

Skill header (print on start):

━━━ Code Reviewer ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Phase progress (print during execution):

  [1/3] Architecture Conformance
    ✓ {N} patterns checked, {M} violations
    ⧖ checking API contract adherence...
    ○ code quality
    ○ performance review

  [2/3] Code Quality
    ✓ SOLID/DRY/KISS audit, {N} findings
    ⧖ analyzing cyclomatic complexity...
    ○ performance review

  [3/3] Performance Review
    ✓ N+1 queries, resource leaks, {N} findings

Completion summary (print on finish — MUST include concrete numbers):

✓ Code Reviewer    {N} findings ({M} Critical, {K} High, {J} Medium)    ⏱ Xm Ys

Config Paths

Read

.production-grade.yaml

paths.services

paths.frontend

paths.tests

paths.architecture_docs

paths.api_contracts

Read-Only Policy

Produces findings and patch suggestions only. Does NOT modify source code — remediation is handled by the orchestrator as a separate task. All output is written exclusively to

Claude-Production-Grade-Suite/code-reviewer/

Security Scope

Security analysis: see security-engineer findings. Code reviewer does NOT perform OWASP or security review.

Context & Position in Pipeline

This skill runs as a quality gate AFTER implementation (

services/

libs/

frontend/

tests/

Inputs:

• docs/architecture/

  ,

  api/

  — ADRs, API contracts (OpenAPI/AsyncAPI), data models, sequence diagrams, architectural decisions, technology choices

• services/

  ,

  libs/

  — Backend services, handlers, repositories, domain models, middleware, infrastructure code

• frontend/

  — UI components, pages, hooks, state management, API clients, routing

• tests/

  ,

  Claude-Production-Grade-Suite/qa-engineer/test-plan.md

  — Test suites, coverage thresholds, test plan, fixtures
• BRD / PRD — Business requirements, acceptance criteria, NFRs

Output Structure

All artifacts are written to

Claude-Production-Grade-Suite/code-reviewer/

Claude-Production-Grade-Suite/code-reviewer/
├── review-report.md                    # Full review report — executive summary + all findings
├── architecture-conformance.md         # ADR compliance check — decision-by-decision audit
├── findings/
│   ├── critical.md                     # Findings that block deployment (data loss risks, correctness bugs)
│   ├── high.md                         # Findings that must be fixed before production (arch violations, major bugs)
│   ├── medium.md                       # Findings that should be fixed soon (code quality, maintainability)
│   └── low.md                          # Findings that are advisory (style, minor optimizations)
├── metrics/
│   ├── complexity.json                 # Cyclomatic complexity per function/module
│   ├── coverage-gaps.json              # Untested code paths, missing edge case coverage
│   └── dependency-analysis.json        # Dependency graph, coupling metrics, circular dependencies
└── auto-fixes/                         # Suggested code patches organized by service
    └── <service>/
        └── <file>.patch.md             # Markdown with before/after code blocks and explanation

Severity Levels

Every finding MUST be assigned exactly one severity level. Use these definitions consistently.

Phases

Execute each phase sequentially. Every phase produces specific output files. Do NOT skip phases.

Parallel Execution Strategy

Phases 1-4 can run in parallel — each reviews a different dimension of the same codebase:

Agent(prompt="Review architecture conformance following Phase 1 checklist. Compare implementation against ADRs. Write to code-reviewer/architecture-conformance.md.", ...)
Agent(prompt="Review code quality following Phase 2 checklist (SOLID, DRY, complexity). Write findings to code-reviewer/findings/.", ...)
Agent(prompt="Review performance following Phase 3 checklist (N+1, caching, bundle size). Write findings to code-reviewer/findings/.", ...)
Agent(prompt="Review test quality following Phase 4 checklist. Cross-reference test plan. Write to code-reviewer/metrics/.", ...)

Wait for all 4 agents, then run Phase 5 (Review Report) sequentially — it compiles all findings.

Execution order:

1. Phases 1-4: Arch Conformance + Code Quality + Performance + Test Quality (PARALLEL)
2. Phase 5: Review Report (sequential — synthesizes all findings)

Phase 1 — Architecture Conformance

Adversarial framing: Assume every ADR was violated. Your job is to find where the implementation diverges from the documented architecture.

Goal: Verify that the implementation faithfully follows the architectural decisions documented in

docs/architecture/

Inputs to read:

• docs/architecture/

  ADRs (every Architecture Decision Record)

• docs/architecture/

  system architecture diagrams, service boundaries, communication patterns

• api/

  API contracts (OpenAPI/AsyncAPI)

• schemas/

  data models and database design

• services/

  ,

  libs/

  full backend source tree

• frontend/

  full frontend source tree

Review checklist:

1. Service boundaries — Does each service own exactly the domain it was designed to own? Are there cross-boundary data accesses that bypass APIs?
2. Communication patterns — If the ADR specifies async messaging between services, verify no synchronous HTTP calls exist between them. If REST was specified, verify no gRPC or GraphQL was introduced without an ADR.
3. Technology choices — If ADR says PostgreSQL, verify no MongoDB usage. If ADR says Redis for caching, verify no in-memory caches that bypass Redis.
4. Data ownership — Does each service have its own database/schema? Are there shared tables or direct DB-to-DB queries that violate data isolation?
5. API contract adherence — Do implemented endpoints match the OpenAPI spec exactly (paths, methods, request/response schemas, status codes)?
6. Authentication/authorization model — Does the implementation follow the auth architecture (JWT validation, RBAC, API keys) as designed?
7. Error handling strategy — Does the implementation follow the error handling patterns defined in the architecture (error codes, error response format, retry policies)?
8. Configuration management — Are secrets managed as designed (env vars, vault, SSM)? Are there hardcoded values that should be configurable?

Output: Write

Claude-Production-Grade-Suite/code-reviewer/architecture-conformance.md

• A table listing every ADR from

  docs/architecture/

  and its conformance status (Conformant / Partial / Violated)
• For each violation: the ADR reference, what was specified, what was implemented, severity, and recommended fix
• For partial conformance: what is correct and what deviates

Phase 2 — Code Quality Analysis

Adversarial framing: Assume every function has a bug. Look for the edge case the author was too close to the code to see.

Goal: Evaluate code against software engineering best practices. Identify structural issues that static analysis tools typically miss.

Inputs to read:

• services/

  ,

  libs/

  all backend source files

• frontend/

  all frontend source files

Review checklist:

SOLID Principles:

1. Single Responsibility — Does each class/module have one reason to change? Flag god-classes and god-functions (functions > 50 lines, classes > 300 lines).
2. Open/Closed — Are extension points used (interfaces, strategy pattern) or is behavior added via if/else chains and switch statements?
3. Liskov Substitution — Do subclasses/implementations honor the contracts of their base types? Are there type-check downcasts that violate polymorphism?
4. Interface Segregation — Are interfaces focused? Flag interfaces with > 7 methods that force implementors to stub unused methods.
5. Dependency Inversion — Do high-level modules depend on abstractions? Flag direct instantiation of infrastructure dependencies (new DatabaseClient()) in business logic.

Code Structure: 6. DRY violations — Identify duplicated logic (not just duplicated strings). Business rules implemented in multiple places are high-severity findings. 7. Cyclomatic complexity — Flag functions with complexity > 10. Calculate and record in

metrics/complexity.json

catch (e: any)

Frontend-Specific: 11. Component size — Flag components > 200 lines. Identify components that mix data fetching, business logic, and presentation. 12. State management — Is state lifted to the appropriate level? Flag prop drilling > 3 levels. Flag global state used for local concerns. 13. Effect management — Flag useEffect with missing dependencies, effects that should be event handlers, and effects without cleanup for subscriptions/timers. 14. Accessibility — Flag interactive elements without ARIA labels, images without alt text, forms without labels, and missing keyboard navigation.

Boundary Safety (see

boundary-safety.md

<Link>

navigate()

/api/*

<a href>

window.location

Output: Write findings to

Claude-Production-Grade-Suite/code-reviewer/findings/

Claude-Production-Grade-Suite/code-reviewer/metrics/complexity.json

Phase 3 — Performance Review

Adversarial framing: Assume every query will be called with 100x the test data. Find where it breaks under load.

Goal: Identify performance bottlenecks, inefficient patterns, and missing optimizations in the codebase.

Inputs to read:

• services/

  ,

  libs/

  all backend source files (especially data access, API handlers, middleware)

• frontend/

  all frontend source files (especially data fetching, rendering, bundle composition)

• docs/architecture/

  NFRs (latency targets, throughput requirements)

Review checklist:

Backend:

1. N+1 queries — Flag any loop that executes a database query per iteration. Verify eager loading or batch queries are used for list endpoints.
2. Missing database indexes — Cross-reference query WHERE clauses and JOIN conditions against migration files. Flag unindexed columns used in frequent queries.
3. Unbounded queries — Flag SELECT queries without LIMIT. Flag list endpoints without pagination.
4. Missing caching — Identify read-heavy, rarely-changing data that should be cached. Flag cache invalidation gaps.
5. Synchronous bottlenecks — Flag synchronous calls to external services in the request path. Verify async/queue patterns for non-time-critical operations (email sending, PDF generation, analytics).
6. Connection pool configuration — Verify database and HTTP client connection pools are sized appropriately and have timeouts configured.
7. Memory leaks — Flag event listeners without cleanup, growing maps/arrays without eviction, unclosed resources (file handles, DB connections, streams).
8. Serialization overhead — Flag large object serialization in hot paths. Verify API responses do not include unnecessary fields.

Frontend: 9. Bundle size — Flag large third-party dependencies imported wholesale (

import _ from 'lodash'

import get from 'lodash/get'

Output: Write performance findings to

Claude-Production-Grade-Suite/code-reviewer/findings/

Claude-Production-Grade-Suite/code-reviewer/metrics/dependency-analysis.json

Phase 4 — Test Quality Review

Adversarial framing: Assume the tests are giving false confidence. Find the untested paths that will fail in production.

Goal: Evaluate the test suites in

tests/

Inputs to read:

• tests/

  all test files

• Claude-Production-Grade-Suite/qa-engineer/test-plan.md

  traceability matrix

• Claude-Production-Grade-Suite/qa-engineer/coverage/thresholds.json

• services/

  ,

  libs/

  source files (to identify untested paths)

Review checklist:

1. Coverage gaps — Identify source files with no corresponding test file. Identify public functions with no test. Identify error handling branches with no test.
2. Assertion quality — Flag tests that only assert on status codes without checking response bodies. Flag tests with no assertions (they always pass). Flag tests that assert on

   true

   /

   false

   instead of specific values.
3. Missing edge cases — For each tested function, identify untested boundary conditions: null inputs, empty collections, maximum values, concurrent access, timeout scenarios.
4. Test independence — Flag tests that depend on execution order. Flag tests that share mutable state through module-level variables. Flag tests that depend on the output of other tests.
5. Test naming — Flag test names that describe implementation ("calls processOrder method") instead of behavior ("creates an order with calculated total when items are valid").
6. Mock quality — Flag mocks that are too permissive (accept any input). Flag mocks that are too brittle (assert on call count or argument order for non-critical interactions).
7. Integration test isolation — Flag integration tests that leave data behind. Flag integration tests that fail when run in a different order.
8. E2E test reliability — Flag E2E tests with hardcoded waits. Flag E2E tests that depend on specific data IDs. Flag E2E tests that are not idempotent.
9. Missing test types — Cross-reference the test plan traceability matrix. Flag acceptance criteria with no corresponding test.
10. Performance test realism — Flag k6 scripts with unrealistic load profiles (e.g., 10,000 VUs for an internal tool). Flag scripts with missing thresholds.

Output: Write test quality findings to

Claude-Production-Grade-Suite/code-reviewer/findings/

Claude-Production-Grade-Suite/code-reviewer/metrics/coverage-gaps.json

Phase 5 — Review Report

Goal: Compile all findings into a structured, actionable review report. Generate auto-fix suggestions for issues where the fix is unambiguous.

Inputs:

• All findings from Phases 1-4
• All metrics from Phases 2-3

Actions:

1. Write

   Claude-Production-Grade-Suite/code-reviewer/review-report.md

   with the following sections:
   • Executive Summary — Total finding count by severity. Overall assessment (Pass / Pass with Conditions / Fail). Top 3 most critical issues.
   • Findings by Category — Architecture, Code Quality, Performance, Test Quality. Each finding includes: ID, severity, category, location (file + line), description, impact, and recommended fix.
   • Metrics Summary — Cyclomatic complexity distribution, coverage gap summary, dependency health.
   • Recommendations — Prioritized list of actions. What to fix now, what to fix next sprint, what to add to tech debt backlog.
   • Sign-off Criteria — Conditions that must be met before this review is considered passed: all Critical findings resolved, all High findings resolved or accepted with justification.

2. Write individual findings files to

   Claude-Production-Grade-Suite/code-reviewer/findings/

   :

   • critical.md

     — Findings that block deployment

   • high.md

     — Findings that must be fixed before production

   • medium.md

     — Findings that should be fixed soon

   • low.md

     — Advisory findings

   Each finding in these files uses the following format:

   ### [FINDING-ID] Short description
   
   **Severity:** Critical | High | Medium | Low
   **Category:** Architecture | Code Quality | Performance | Test Quality
   **Location:** `path/to/file.ts:42`
   
   **Description:**
   What the issue is and why it matters.
   
   **Impact:**
   What happens if this is not fixed.
   
   **Evidence:**
   ```code
   // The problematic code
   

   Recommendation: How to fix it, with a code example if applicable.

3. Generate auto-fix suggestions for findings where the fix is mechanical and unambiguous:

   • Missing null checks
   • Missing auth middleware
   • Missing input validation
   • Missing error handling
   • Unused imports
   • Missing index definitions

   Write each auto-fix to

   Claude-Production-Grade-Suite/code-reviewer/auto-fixes/<service>/<file>.patch.md

   with:
   • Finding ID reference
   • Before code block
   • After code block
   • Explanation of the change

4. Compile metrics:

   • Claude-Production-Grade-Suite/code-reviewer/metrics/complexity.json

     — Cyclomatic complexity per function, flagged functions with complexity > 10

   • Claude-Production-Grade-Suite/code-reviewer/metrics/coverage-gaps.json

     — List of untested files, untested functions, untested branches

   • Claude-Production-Grade-Suite/code-reviewer/metrics/dependency-analysis.json

     — Service dependency graph, coupling score per service, circular dependency detection

Output: Write all report files, findings, metrics, and auto-fixes to

Claude-Production-Grade-Suite/code-reviewer/

Common Mistakes

docs/architecture/

frontend/

frontend/

services/

frontend/

tests/

Execution Checklist

Before marking the skill as complete, verify:

• architecture-conformance.md

  audits every ADR in

  docs/architecture/

  with a conformance status
• Every finding has: ID, severity, category, file location, description, impact, and recommendation
• Performance review checks for N+1 queries, missing indexes, unbounded queries, and caching gaps
• Test quality review cross-references the

  Claude-Production-Grade-Suite/qa-engineer/test-plan.md

  traceability matrix for coverage gaps

• review-report.md

  has an executive summary with total finding counts and overall assessment
• Findings are correctly distributed across

  critical.md

  ,

  high.md

  ,

  medium.md

  , and

  low.md

• metrics/complexity.json

  has per-function cyclomatic complexity scores

• metrics/coverage-gaps.json

  identifies untested files, functions, and branches

• metrics/dependency-analysis.json

  maps service dependencies and flags circular dependencies
• Auto-fixes exist for all mechanical issues (missing null checks, missing auth, etc.)
• No files were created or modified outside of Claude-Production-Grade-Suite/code-reviewer/
• The report is actionable — a developer can read a finding and know exactly what to fix and where
• No OWASP or security review was performed — security analysis is deferred to security-engineer