invisible-error-detect

Detect invisible runtime and logic errors in code changes with dual-agent analysis.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/JYHTHEGREAT/jyh-system --skill invisible-error-detect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: invisible-error-detect
Source: https://github.com/JYHTHEGREAT/jyh-system/tree/main/skills/invisible-error-detect
Command: npx skills add https://github.com/JYHTHEGREAT/jyh-system --skill invisible-error-detect

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Detects "invisible" errors that standard code review and automated checks commonly miss by combining forward code-driven analysis with backward failure-driven reasoning to find logic gaps, runtime triggers, and scenario-specific vulnerabilities before handoff verification completes.

Core Features & Use Cases

  • Dual-agent parallel analysis: a forward-facing Error Detector and a backward-facing Failure Finder run independently and results are merged to highlight high-confidence findings.
  • Conditional execution and modes: automatic trigger based on git diff size and sensitive paths, a --deep-check override for forced runs, and a --lite mode that simulates both perspectives without spawning agents.
  • Structured deduplication and noise filtering: normalizes findings, cross-checks against prior code-review output, applies a 2-of-4 noise gate, produces a fragility map, and emits a prioritized report with PASS/WARN/BLOCK verdicts and revalidation loops.
  • Use case: run during handoff-verify on changes to auth, payments, migrations, or schema files to catch runtime triggers and missed failure modes before merging.

Quick Start

Run the invisible-error-detect skill on the current branch to scan recent changes and produce a prioritized invisible error report.

Frequently Asked Questions about invisible-error-detect

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

FAQPage Schema
How do I detect hidden runtime and logic errors in code changes before merging?

To detect hidden runtime and logic errors in code changes, combine forward code-driven analysis with backward failure-driven reasoning. This dual-agent approach identifies logic gaps, runtime triggers, and scenario-specific vulnerabilities that standard code reviews typically miss before handoff verification completes.

What is the best way to run invisible error detection on security-sensitive modules and migrations?

The best way to run invisible error detection on security-sensitive modules and migrations is executing a dual-agent parallel analysis during handoff verification. This process merges independent forward and backward findings, applies noise gating, and generates a structured report with PASS, WARN, or BLOCK verdicts for prioritized fixes.

Does invisible error detection work automatically based on git diff size and sensitive paths?

Invisible error detection works automatically based on git diff size and sensitive paths. It triggers conditional execution for medium-to-large code changes, while also offering a --deep-check override for forced runs and a --lite mode that simulates both analytical perspectives without spawning additional agents.

How do I reduce false positives when finding missed failure modes in pull requests?

Reduce false positives when finding missed failure modes by applying structured deduplication and a 2-of-4 noise gate. The system normalizes findings, cross-checks them against prior code-review outputs, and generates a fragility map to ensure only high-confidence results are highlighted in the final report.

When do I need dual-agent static analysis for my pull requests?

You need dual-agent static analysis for pull requests involving medium-to-large code changes, especially within auth, payments, migrations, or schema files. It is essential when standard automated checks are insufficient to catch complex runtime triggers and missed failure modes prior to merging.

What are the limitations of using a lite mode for finding logic gaps in code?

The limitation of using lite mode for finding logic gaps is that it simulates both forward and backward perspectives without spawning agents. While faster, this simulation may lack the deep analytical confidence of a full dual-agent run, potentially missing complex runtime triggers in highly sensitive code.