What are the two core purposes of review-standards?

Quality Gate (catch bugs, vulnerabilities, design issues) and Knowledge Sharing (spread understanding across the team).

What warning signs in tests should you watch for?

Tests that verify method call counts, tests that break on refactoring, every class having a test file (London school smell), and mocks setup longer than the actual test.

review-standards

npx machina-cli add skill kicchann/reqord/review-standards --openclaw

Files (1)

SKILL.md

1.7 KB

Code Review Guideline

This skill provides language-agnostic principles for conducting effective code reviews.

When to Use This Skill

Reviewing pull requests
Providing constructive feedback
Setting up review standards for a team
Self-reviewing code before submission

Core Philosophy

Code review serves two purposes:

Quality Gate: Catch bugs, vulnerabilities, and design issues
Knowledge Sharing: Spread understanding across the team

Quick Reference

Review Priorities (Highest -> Lowest)

Correctness: Does it work correctly?
Security: Any vulnerabilities?
Architecture: Does it follow project patterns?
Test Quality: Are tests valuable (not just present)?
Readability: Can others understand it?
Performance: Any obvious issues?

Test Quality Signals

Good Signs:

Tests verify behavior, not implementation
Tests use real objects where possible
Mocks only at external boundaries
Clear Arrange-Act-Assert structure

Warning Signs:

Tests verify method call counts
Tests break on refactoring
Every class has corresponding test file (London school smell)
Mock setup longer than actual test

Resources

resources/review-checklist.md - General review checklist
resources/tdd-verification.md - TDD practice verification

Integration with Other Skills

tdd-principles: Detailed test quality criteria
architecture-principles: Architecture compliance checking

Source

git clone https://github.com/kicchann/reqord/blob/main/plugins/reqord/skills/review-standards/SKILL.mdView on GitHub

Overview

This skill formalizes code review into language-agnostic principles focused on correctness, security, architecture compliance, and test quality. It supports reviewers by providing a clear checklist and emphasizes knowledge sharing across the team.

How This Skill Works

Follow the prioritized review checklist: Correctness, Security, Architecture, Test Quality, Readability, and Performance. Assess test quality signals and watch for common anti-patterns; use the warning signs to flag risks before merging.

When to Use It

Reviewing pull requests
Providing constructive feedback
Setting up review standards for a team
Self-reviewing code before submission

Quick Start

Step 1: Read the PR and map it to the six priorities (Correctness, Security, Architecture, Test Quality, Readability, Performance)
Step 2: Inspect tests for behavior verification, real objects, proper mocks, and a clear Arrange-Act-Assert structure
Step 3: Leave concrete, actionable feedback and cite relevant standards and resources

Best Practices

Follow the six Review Priorities in order of impact
Prioritize test quality signals over mere test presence
Ensure architecture alignment with project patterns
Give concrete, actionable feedback linked to code and tests
Refer to the review resources when needed (review-checklist.md, tdd-verification.md)

Example Use Cases

Review a PR focusing on correctness and security while checking for architecture conformance
Assess test quality signals by verifying behavior with real objects and a clear Arrange-Act-Assert structure
Flag tests that break on refactoring or verify method call counts unnecessarily
Identify the London school smell by spotting when every class has a test file
Triage a PR by referencing resources/review-checklist.md and resources/tdd-verification.md

Frequently Asked Questions

Add this skill to your agents