implementation-validator

Validate code implementations against acceptance claims via adversarial review.

8|Updated Jun 18, 2026

Search Tags:#diff analysis #code review #acceptance criteria #implementation validation #adversarial review #severity calibration #pre-merge verification

Ready to run

npx skills add https://github.com/ddobrin/plan-skills --skill implementation-validator

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: implementation-validator
Source: https://github.com/ddobrin/plan-skills/tree/main/plugins/plan/skills/implementation-validator
Command: npx skills add https://github.com/ddobrin/plan-skills --skill implementation-validator

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill identifies defects that remain after code changes by subjecting the implementation to independent adversarial review before merge.

Core Features & Use Cases

Independent Skeptic Panel: Dispatches three isolated reviewers to attack a diff or refute explicit acceptance claims.
Majority Validation: Keeps only findings confirmed by at least two of three skeptics and calibrates their severity based on actual impact.
Persisted Review Evidence: Produces a structured Markdown report covering confirmed defects, unconfirmed concerns, failed attacks, severity calibration, and remediation actions.
Use Case: After completing a feature, use this Skill to test its failure paths, edge cases, concurrency behavior, resource correctness, and regression risks before merging.

Quick Start

Use the implementation-validator skill to adversarially validate the current implementation diff against its acceptance claims and save the resulting review report.

Frequently Asked Questions about implementation-validator

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I validate code changes against acceptance criteria before merging?▼

To validate code changes before merging, an independent skeptic panel reviews the diff to expose defects that contradict stated acceptance claims. It confirms only findings agreed upon by multiple reviewers, calibrates severity based on actual impact, and outputs a persisted Markdown review report.

What is adversarial code review and how does it catch defects in a diff?▼

Adversarial code review dispatches isolated reviewers to attack a diff and refute explicit acceptance claims. It catches defects by keeping only findings confirmed by at least two of three skeptics, calibrating their severity, and documenting failed attacks alongside remediation actions.

How do I perform pre-merge verification on feature implementations and bug fixes?▼

Pre-merge verification tests feature implementations and bug fixes by subjecting them to independent adversarial review. It identifies failure paths, edge cases, concurrency behavior, resource correctness, and regression risks by having multiple skeptics attempt to refute the implementation's acceptance claims.

Can I use implementation validation for refactoring tasks and existing diff reviews?▼

Yes, implementation validation applies to refactoring tasks, diff reviews, and adversarial verification of existing findings. It processes completed code changes by dispatching independent skeptic agents to attack the diff, aggregating confirmed defects through a majority gate, and generating a structured JSON verdict.

What is the best way to calibrate the severity of defects found during code review?▼

The best way to calibrate defect severity during code review is through majority-gate aggregation from an independent skeptic panel. It calibrates severity based on actual impact, filtering out unconfirmed concerns and retaining only defects validated by multiple reviewers in a structured Markdown report.

Why does my implementation pass tests but still fail acceptance claims during pre-merge checks?▼

Implementations can pass tests but fail acceptance claims because standard tests often miss failure paths, edge cases, and concurrency behavior. Pre-merge checks expose these defects by applying adversarial verification where isolated reviewers actively attempt to refute the stated behavior and document regression risks.