All skills
wshobson avatar

/multi-reviewer-patterns

@a5ab5d8
by Seth Hobsonwshobson/agents40k stars
4,281

Coordinate parallel code reviews across multiple quality dimensions with finding deduplication, severity calibration, and consolidated reporting. Use this skill when organizing multi-reviewer code reviews, calibrating finding severity, or consolidating review results.

Use this Skill: https://skilld.dev/gh/wshobson/agents/multi-reviewer-patterns

This session only. Nothing lands on disk.

referencesreview-dimensions.md

≈1k tokens on demand. Your agent reads this file only when SKILL.md points to it.

Review Dimension Checklists

Detailed checklists for each review dimension that reviewers follow during parallel code review.

Security Review Checklist

Input Handling

  • All user inputs are validated and sanitized
  • SQL queries use parameterized statements (no string concatenation)
  • HTML output is properly escaped to prevent XSS
  • File paths are validated to prevent path traversal
  • Request size limits are enforced

Authentication & Authorization

  • Authentication is required for all protected endpoints
  • Authorization checks verify user has permission for the action
  • JWT tokens are validated (signature, expiry, issuer)
  • Password hashing uses bcrypt/argon2 (not MD5/SHA)
  • Session management follows best practices

Secrets & Configuration

  • No hardcoded secrets, API keys, or passwords
  • Secrets are loaded from environment variables or secret manager
  • .gitignore includes sensitive file patterns
  • Debug/development endpoints are disabled in production

Dependencies

  • No known CVEs in direct dependencies
  • Dependencies are pinned to specific versions
  • No unnecessary dependencies that increase attack surface

Performance Review Checklist

Database

  • No N+1 query patterns
  • Queries use appropriate indexes
  • No SELECT * on large tables
  • Pagination is implemented for list endpoints
  • Connection pooling is configured

Memory & Resources

  • No memory leaks (event listeners cleaned up, streams closed)
  • Large data sets are streamed, not loaded entirely into memory
  • File handles and connections are properly closed
  • Caching is used for expensive operations

Computation

  • No unnecessary re-computation or redundant operations
  • Appropriate algorithm complexity for the data size
  • Async operations used where I/O bound
  • No blocking operations on the main thread

Architecture Review Checklist

Design Principles

  • Single Responsibility: each module/class has one reason to change
  • Open/Closed: extensible without modification
  • Dependency Inversion: depends on abstractions, not concretions
  • No circular dependencies between modules

Structure

  • Clear separation of concerns (UI, business logic, data)
  • Consistent error handling strategy across the codebase
  • Configuration is externalized, not hardcoded
  • API contracts are well-defined and versioned

Patterns

  • Consistent patterns used throughout (no pattern mixing)
  • Abstractions are at the right level (not over/under-engineered)
  • Module boundaries align with domain boundaries
  • Shared utilities are actually shared (no duplication)

Testing Review Checklist

Coverage

  • Critical paths have test coverage
  • Edge cases are tested (empty input, null, boundary values)
  • Error paths are tested (what happens when things fail)
  • Integration points have integration tests

Quality

  • Tests are deterministic (no flaky tests)
  • Tests are isolated (no shared state between tests)
  • Assertions are specific (not just "no error thrown")
  • Test names clearly describe what is being tested

Maintainability

  • Tests don't duplicate implementation logic
  • Mocks/stubs are minimal and accurate
  • Test data is clear and relevant
  • Tests are easy to understand without reading the implementation

Accessibility Review Checklist

Structure

  • Semantic HTML elements used (nav, main, article, button)
  • Heading hierarchy is logical (h1 → h2 → h3)
  • ARIA roles and properties used correctly
  • Landmarks identify page regions

Interaction

  • All functionality accessible via keyboard
  • Focus order is logical and visible
  • No keyboard traps
  • Touch targets are at least 44x44px

Content

  • Images have meaningful alt text
  • Color is not the only means of conveying information
  • Text has sufficient contrast ratio (4.5:1 for normal, 3:1 for large)
  • Content is readable at 200% zoom

Source: SKILL.md on GitHub

No alerts16d5 checks · Risk SAFE
  • Gen Agent Trust Hub16d

    This skill provides a structured framework for conducting multi-reviewer code reviews, including deduplication logic, severity criteria, and checklists for security, performance, and accessibility. It contains no executable code or external dependencies and adheres to security best practices.

  • Socket16d

    No alerts

  • Snyk16d

    Risk: LOW · No issues

  • Runlayer7mo

    2 files scanned · No issues

  • ZeroLeaks5mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at a5ab5d8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 3 days ago.

Activeupdated 8 months ago
version
1.0.2
  • code-review
  • multi-reviewer
  • findings-deduplication
  • severity-calibration
  • quality-assurance
  • architecture-review
  • security-review
  • performance-review
  • reporting

README badge

README badge for wshobson/agents/multi-reviewer-patterns

Coordinates parallel code reviews across multiple quality dimensions (security, performance, architecture, testing, accessibility) with rules for deduplicating findings, calibrating severity consistently, and consolidating results into a single report. Use this skill when running multi-reviewer audits or need to merge overlapping findings with standardized severity ratings.

Generated from the current SKILL.md.

How do I decide which review dimensions to assign to different reviewers?
The skill provides a table of five dimensions (Security, Performance, Architecture, Testing, Accessibility) with guidance on when to include each. For example, always include Security for code handling user input, include Performance for data access changes, and include Accessibility for UI changes. Recommended combinations are provided for common scenarios like API endpoints, frontend components, and authentication changes.
What do I do when multiple reviewers report the same issue at the same location?
Merge the findings into one, crediting all reviewers. Use the higher severity rating if reviewers disagree, and keep the more detailed description. If reviewers report different issues at the same location, keep both as separate findings and tag them as co-located.
How should I calibrate severity ratings across different reviewers?
The skill provides explicit severity criteria (Critical, High, Medium, Low) based on impact and likelihood. Use the calibration rules provided: security vulnerabilities exploitable by external users are always Critical or High, performance issues in hot paths are at least Medium, and code style issues with no functional impact are Low.
What format should the consolidated review report follow?
The skill includes a template that organizes findings by severity level (Critical, High, Medium, Low), includes location and dimension for each finding, and concludes with a summary table showing finding counts by dimension and severity, plus an overall recommendation.

Generated from the current SKILL.md. These answers refresh after source changes.