parity-check-audit

Compare two application versions to verify feature parity and detect regressions.

Updated Feb 25, 2026
One-click install
npx skills add https://github.com/LayerDynamics/Lore --skill parity-check-audit
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: parity-check-audit
Source: https://github.com/LayerDynamics/Lore/tree/main/lore/skills/parity-check-audit
Command: npx skills add https://github.com/LayerDynamics/Lore --skill parity-check-audit

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill prevents silent regressions and ensures that critical features and behaviors are preserved when comparing different versions of an application, such as during rewrites, migrations, or refactors.

Core Features & Use Cases

  • Structural Mapping: Compares file inventories, dependencies, and configurations between versions.
  • Feature Verification: Systematically checks if all original features are present and behave as expected in the new version.
  • Deep Comparison: Performs line-level analysis to catch subtle logic differences and common regression patterns.
  • Use Case: After a major refactor of your authentication module, use this skill to confirm that all login methods, password reset flows, and session management behaviors from the old version are still fully functional and identical in the new version.

Quick Start

Use the parity-check-audit skill to compare the local directory './app-v1' against './app-v2' with a standard depth.

Frequently Asked Questions about parity-check-audit

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

FAQPage Schema
How do I verify feature parity between two application versions after a refactor?

Feature parity verification involves systematically comparing two application versions to map structural differences, verify feature implementations against a registry, and perform deep logic analysis to detect silent regressions and ensure behaviors are preserved.

What is the best way to detect silent regressions during a migration?

Detecting silent regressions during a migration requires a deep comparison tool that performs line-level analysis to catch subtle logic differences and common regression patterns, ensuring critical features and behaviors are preserved across the old and new versions.

Can I compare code versions using Git refs or remote repositories?

Yes, you can compare code versions using Git ref-to-ref and remote-to-local comparisons, alongside standard directory-to-directory comparisons, with adjustable depth levels to customize the comprehensiveness of the version audit.

How do I check if all original features are still present after rewriting a module?

To check if all original features are present after a rewrite, use a feature verification process that systematically maps file inventories, dependencies, and configurations, comparing the new feature implementations against a registry of the original version's behaviors.

Does feature parity auditing work for directory-to-directory comparisons?

Yes, feature parity auditing supports directory-to-directory comparisons, allowing you to directly map structural differences and perform deep logic analysis between two local application folders to verify refactoring correctness.

When do I need to perform a deep code comparison instead of a standard version audit?

You need a deep code comparison when checking for subtle logic differences and silent regressions, utilizing adjustable depth levels to perform thorough line-level analysis beyond standard structural mapping of files and dependencies.