Code Review Gatekeeper: A Skill That Stops Bad Merges

Where this fits

You've just spent an hour directing an agent to build a payment integration. It passes tests, the diff looks clean, and you're about to hit merge. But the agent never checked whether the implementation actually matches the original requirements—edge cases, error handling, security boundaries. That's the gap this skill fills: it inserts a structured code review step into your agent's workflow, before any merge happens. It reads your plan or requirements, scans the changed code, and returns a severity-ranked list of issues (Critical / Important / Minor) with concrete fix suggestions.

Why agents benefit

• Requirement-aware review — The skill doesn't just lint or check style; it compares the implementation against your stated plan, catching functional drift that unit tests miss.
• Severity triage — Instead of a flat list of nitpicks, it classifies findings so the agent (or you) can prioritize the truly breaking issues first.
• Iron-law enforcement — The skill's description carries NO MERGE WITHOUT CODE REVIEW FIRST, so any agent following the skill will pause and review before completing a merge task.
• Cross-platform compatibility — Works with Claude Code, OpenAI Codex, and ChatGPT, meaning the same discipline applies regardless of which agent runtime you use.
• Bug feedback loop — It integrates with a companion bug-collection skill, so if the reviewer itself has flaws, those get recorded and reported without polluting user code.

Practical scenarios

Post-feature implementation checkpoint

After your agent finishes a new endpoint, you invoke the reviewer with the original task description and the diff. It flags a missing input validation on a user-supplied field, marked as Critical. You fix it before the agent moves on.

Pre-merge safety net for a pull request

Your agent is about to merge a branch that touches database migrations. The reviewer notices the migration lacks a rollback script and the new column has no default for existing rows—Important findings that could break production on deploy.

Refactoring without regression

You ask an agent to refactor a module for readability. The reviewer compares the refactored code against the old behavior and spots a subtle change in how errors are propagated, preserving correct behavior while still allowing the refactor.

Add it to your agent workflow

Install it into your agent's project with:

npx skills add huangwb8/skills --skill code-reviewer

Then instruct your agent at task start: "Complete the feature, then run the code-reviewer skill against your changes before reporting done." The skill will generate a review report in ./.bensz-api/task-*/output/. You can also call it directly on demand.

Compare before adopting

Before making this a permanent part of your stack, compare along these lines:

• Quality signals — Does the skill actually catch real bugs in your codebase, or just produce generic advice? Run it on a past risky PR.
• Maintenance freshness — Check the repo's last commit date and issue resolution rate. Skills that track agent platform changes are more reliable.
• Alternatives — Try a manual prompt like "review this diff against these requirements" before committing to a dedicated skill.
• Workflow fit — Will your agent reliably invoke this skill without extra prompting? If not, you may need wrapper automation.

Why it is worth tracking

With 48 stars and an active author (huangwb8), this skill shows steady community adoption. The explicit iron-law phrasing and the integration with a bug-collection skill signal deliberate design, not a passive prompt. Watch for updates that add more rubric dimensions (e.g., test coverage or performance checks). If your team regularly ships incomplete agent-generated code, this skill deserves a trial run. For a broader perspective on agent skills, keep an eye on OpenAgentSkill for community ratings and comparisons.