synthesis-implementation-integrity

Identify incomplete implementations and hidden gaps after non-trivial changes.

15|2|Updated Mar 17, 2026
One-click install
npx skills add https://github.com/synthesisengineering/synthesis-skills --skill synthesis-implementation-integrity-synthesisengineering
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: synthesis-implementation-integrity
Source: https://github.com/synthesisengineering/synthesis-skills/tree/main/synthesis-implementation-integrity
Command: npx skills add https://github.com/synthesisengineering/synthesis-skills --skill synthesis-implementation-integrity-synthesisengineering

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams verify that a non-trivial implementation is truly complete, catching gaps that tests alone may miss and preventing overconfidence before shipping.

Core Features & Use Cases

  • Seven integrity passes that assess data flow, placeholders, test honesty, environment parity, companion changes, and boundary conditions after any substantial change.
  • Generates a structured Integrity Report that highlights gaps and actionable next steps for remediation.
  • Suitable for PR-ready checks, feature branches, and post-implementation self-audits to reduce production risk.

Quick Start

Run the seven integrity passes on the latest feature branch to obtain an evidence-based verification of completeness.

Frequently Asked Questions about synthesis-implementation-integrity

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

FAQPage Schema
How do I verify implementation completeness and find hidden gaps after non-trivial code changes?

Implementation completeness verification requires running seven integrity passes across data flows, migrations, and external dependencies. This process assesses chain completeness, placeholder detection, test honesty, and environment parity to output an actionable integrity report highlighting gaps.

What is test honesty in code review and how does it catch incomplete implementations?

Test honesty in code review verifies that tests genuinely validate behavior rather than passing through placeholders or deferrals. It is one of seven integrity passes that detect hidden gaps in non-trivial implementations, ensuring tests provide evidence-based confirmation of completeness.

How do I audit a feature branch for hidden placeholders and deferred code before merging?

Auditing a feature branch for placeholders involves applying integrity passes that detect deferral patterns and incomplete code segments. The process evaluates diminishing attention and companion change completeness, generating a structured report with actionable remediation steps for production risk reduction.

Does environment parity verification work for production-like environments and external dependencies?

Environment parity verification works by comparing production-like environments against development configurations to identify discrepancies across external dependencies. It is applied to branches and PRs as part of boundary verification, ensuring end-to-end completeness before shipping substantial changes.

When should I use adversarial verification instead of standard automated testing?

Adversarial verification should be used when standard tests may miss gaps in non-trivial implementations. It applies seven integrity passes covering chain completeness, companion changes, and boundary conditions to prevent overconfidence before shipping, catching issues that conventional testing alone cannot detect.

What are the limitations of integrity passes for post-implementation auditing?

Integrity passes for post-implementation auditing are limited to verifying completeness of existing changes rather than designing new architectures. They require production-like environments and accurate dependency mapping to function effectively, and they do not replace functional testing but complement it.